Esta página foi traduzida pela API Cloud Translation.

Usar rotas

Veja nesta página como criar e gerenciar rotas para redes de nuvem privada virtual (VPC) no Google Cloud. Nesta página, presumimos que você conhece os diferentes tipos de rotas do Google Cloud e as características delas, conforme descrito em Rotas.

Cada nova rede tem dois tipos de rotas geradas pelo sistema: uma rota padrão, que pode ser removida ou substituída, e uma rota de sub-rede para cada uma das respectivas sub-redes. Não é possível remover uma rota de sub-rede, a menos que você exclua a sub-rede correspondente.

Além das rotas geradas pelo sistema, é possível criar outras rotas estáticas personalizadas.

Listar rotas para uma rede VPC

Use a Google Cloud CLI ou a API para listar e visualizar detalhes sobre os seguintes tipos de rotas:

Nem os comandos da CLI gcloud nem os métodos de API mostram os seguintes tipos de rotas:

Para ver a rota completa, use o console do Google Cloud. Para listar e descrever rotas com base em políticas, consulte Usar rotas com base em políticas.

Console

No console do Google Cloud, acesse a página Rotas.

Acessar a página Rotas
Na guia Rotas efetivas, faça o seguinte:
- Escolha uma rede VPC.
- Escolha uma região.
Clique em Visualizar.
É possível filtrar por propriedades como o tipo de rota, o intervalo de IP de destino e o tipo do próximo salto.
Opcional: ative a opção Mostrar rotas suprimidas para exibir rotas suprimidas. Para visualizar o motivo pelo qual uma rota for suprimida, confira o ícone na coluna Status.

gcloud

Para listar e visualizar detalhes das rotas, use os comandos gcloud compute routes. Rotas de sub-rede e rotas estáticas da rede VPC local e todas as redes VPC com peering são exibidas. Outros tipos de trajeto não são exibidos. Para conferir todas as rotas, use o console do Google Cloud.

Para listar rotas, faça o seguinte:

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

Para ver detalhes de uma rota, faça o seguinte:

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

Substitua:

NETWORK_NAME: o nome da rede VPC.
PROJECT_ID: o ID do projeto que contém sua rede VPC.
ROUTE_NAME: o nome da rota.

API

Para listar e visualizar detalhes das rotas, use os métodos routes.list e routes.get. Rotas de sub-rede e rotas estáticas da rede VPC local e todas as redes VPC com peering são exibidas. Outros tipos de trajeto não são exibidos. Para conferir todas as rotas, use o console do Google Cloud.

Para listar rotas, faça o seguinte:

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

Para ver detalhes de uma rota, faça o seguinte:

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

Substitua:

PROJECT_ID: o ID do projeto que contém sua rede VPC.
NETWORK_URL: o URL da rede VPC.
ROUTE_NAME: o nome da rota.

Listar rotas aplicáveis à interface de rede de uma VM

É possível usar o Console do Google Cloud para ver rotas aplicáveis para a interface de rede de uma VM. Essa visualização restringe a lista de rotas que podem ser usadas para o tráfego de saída.

Para ver as rotas aplicáveis para uma interface de rede específica de uma VM, siga estas etapas.

Console

No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
Localize uma instância de VM na lista. No menu Mais ações no final da linha, selecione Ver detalhes da rede.
Se uma instância tiver várias interfaces de rede, na seção Detalhes da interface de rede, selecione a interface de rede que você quer ver.
Na seção Detalhes de firewall e rotas, clique na guia Rotas para ver todas as rotas que se aplicam à interface de rede, classificadas por nome de rota.

Adicionar e remover rotas estáticas

É possível adicionar ou remover rotas estáticas e com base em políticas locais para sua rede VPC. Nesta seção, descrevemos como adicionar e excluir rotas estáticas locais. Para mais informações sobre como adicionar e remover rotas com base em políticas, consulte Usar rotas com base em políticas.

As rotas de sub-rede são adicionadas e excluídas automaticamente quando você adiciona ou exclui uma sub-rede. Para mais informações sobre como adicionar e remover sub-redes, consulte Trabalhar com sub-redes.

Todas as rotas em uma rede VPC conectadas por peering de rede VPC precisam ser manipuladas na rede VPC que exporta essas rotas. Para mais informações, consulte Opções de troca de rota.

Antes de adicionar uma rota estática

Antes de adicionar uma rota estática, considere o seguinte:

Entenda os diferentes tipos de próximos saltos que as rotas estáticas podem usar. Para informações sobre os diferentes tipos de próximos saltos de rota estática, incluindo quais oferecem suporte a destinos IPv6, consulte Próximos saltos e recursos.
A menos que você use sub-redes híbridas, uma rota estática não pode ter um intervalo de destino que corresponda ou seja mais específico do que o intervalo de destino de uma sub-rede ou rota de sub-rede de peering. Para mais detalhes, consulte Interações com rotas estáticas personalizadas na visão geral de Rotas e Interações de sub-rede e rota estática na documentação do Peering de redes VPC.
Para evitar conflitos ao usar uma rede de modo automático, não crie rotas estáticas com destinos que caibam dentro de 10.128.0.0/9. Revise os intervalos IPv4 do modo automático para saber detalhes.
Destinos para rotas estáticas personalizadas não podem se sobrepor a nenhum intervalo interno alocado.
Verifique se você tem familiaridade com instâncias como próximos saltos antes de criar uma rota estática personalizada que use uma VM como seu próximo salto. O Google Cloud só confirma que uma VM existe quando você cria a rota, se você escolher uma instância de próximo salto.
Se você criar uma rota usando uma tag de rede, somente as VMs com essa tag receberão essa rota. No entanto, as VMs com tags ainda recebem todas as rotas sem tag de rede.

Adicionar uma rota estática

Adicione uma rota estática a uma rede. Para mais informações sobre os diferentes tipos de próximos saltos de rota estática, incluindo quais oferecem suporte a destinos IPv6, consulte Próximos saltos e recursos.

Console

No Console do Google Cloud, acesse a página Rotas.

Acessar a página Rotas
Clique na guia Gerenciamento de rotas.
Clique em Criar rota.
Especifique um nome e uma descrição para a rota.
Na lista Rede, selecione uma rede para a rota.
Na lista Tipo de rota, selecione Rota estática.
Na lista Versão do IP, selecione a versão do IP necessária:
- Para criar uma rota estática IPv4, selecione IPv4.
- Para criar uma rota IPv6 estática, selecione IPv6.
Especifique um intervalo de IP de destino. O maior destino possível é 0.0.0.0/0 para IPv4 ou ::/0 para IPv6.
Especifique uma prioridade para a rota. A prioridade pode ser de 0 (a prioridade mais alta) a 65535 (a menor prioridade).
Para tornar a rota aplicável somente para selecionar instâncias com tags de rede correspondentes, especifique-as no campo Tags da instância. Deixe o campo em branco para tornar a rota aplicável a todas as instâncias na rede.
Selecione um próximo salto para a rota:
- Gateway de Internet padrão: entrega pacotes para a Internet e para APIs e serviços do Google.
- Especificar uma instância: entrega pacotes para a interface de rede de uma instância de VM. Especifique a instância de VM por nome e zona. Se o destino da rota for um endereço IPv6, a instância da VM precisará ser pilha dupla.
- Especificar o endereço IP de uma instância: especifique o endereço IP de uma instância atual na rede VPC. Para rotas estáticas IPv6 (pré-lançamento), a instância precisa ser dual-stack. Para conferir restrições importantes para endereços IP de próximo salto válidos, consulte próximos saltos da rota estática.
- Especificar túnel VPN: entrega pacotes para um túnel VPN clássica usando roteamento estático.
- Especificar uma regra de encaminhamento de um balanceador de carga de rede de passagem interna: entrega pacotes a um balanceador de carga de rede de passagem interna que é especificado pelo próprio balanceador nome e região da regra de encaminhamento. A regra de encaminhamento pode ter um endereço IPv4 ou IPv6 (Visualização). A versão IP da regra de encaminhamento especificada precisa corresponder à versão IP da rota estática criada.
Clique em Criar.

gcloud

Crie uma nova rota estática personalizada com o comando da CLI gcloud a seguir:

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

Substitua:

ROUTE_NAME: o nome da rota
NETWORK: o nome da rede VPC que contém a rota
DESTINATION_RANGE: os endereços IPv4 ou IPv6 de destino a que essa rota se aplica. O maior destino possível é 0.0.0.0/0 para IPv4 ou ::/0 para IPv6.
PRIORITY: a prioridade da rota, que pode ser de 0 (a prioridade mais alta) a 65535 (a prioridade mais baixa).
NEXT_HOP_SPECIFICATION: o próximo salto da rota estática. Use um dos parâmetros ou uma combinação de parâmetros a seguir:
- --next-hop-gateway=default-internet-gateway: entrega pacotes para a Internet e as APIs e os serviços do Google.
- --next-hop-instance=INSTANCE_NAME e --next-hop-instance-zone=ZONE: entregam pacotes para a interface de rede de uma instância de VM. Especifique a instância de VM por nome e zona. Se o destino da rota for um endereço IPv6, a instância da VM precisará ser pilha dupla.
- --next-hop-address=ADDRESS: especifique um endereço IP de uma instância atual na rede VPC. Para rotas estáticas IPv6 (pré-lançamento), a instância precisa ser dual-stack. Para conferir restrições importantes para endereços IP de próximo salto válidos, consulte Próximos saltos e recursos.
- --next-hop-vpn-tunnel=VPN_TUNNEL_NAME e --next-hop-vpn-tunnel-region=REGION: enviam pacotes para um túnel da VPN clássica usando roteamento estático.
- --next-hop-ilb=FORWARDING_RULE e --next-hop-ilb-region=REGION: entregam pacotes para um balanceador de carga de rede de passagem interna. Especifique a regra de encaminhamento pelo nome (ou endereço IPv4 ou IPv6 (pré-lançamento)) e pela região. A versão do IP da regra de encaminhamento especificada precisa corresponder à versão do IP da rota estática criada.
Para fazer com que a rota estática personalizada se aplique somente a seleções de VMs por tag de rede, adicione a sinalização --tags e especifique uma ou mais tags de rede. Para saber mais informações sobre como as tags de rede e as rotas estáticas personalizadas funcionam juntas, consulte Rotas aplicáveis na visão geral de rotas. É possível usar tags com qualquer rota estática personalizada.

Para mais informações sobre a sintaxe da CLI gcloud, consulte a documentação do SDK.

API

Crie uma nova rota estática personalizada.

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

Substitua:

PROJECT_ID: o ID do projeto em que sua rota é criada.
ROUTE_NAME: o nome da rota
NETWORK: o nome da rede VPC que contém a rota
DESTINATION_RANGE: o intervalo de endereços IPv4 ou IPv6 de destino a que esta rota se aplica. O maior destino possível é 0.0.0.0/0 para IPv4 ou ::/0 para IPv6.
PRIORITY: a prioridade da rota, que pode ser de 0 (a prioridade mais alta) a 65535 (a prioridade mais baixa).
NEXT_HOP_SPECIFICATION: o próximo salto da rota estática. Use um dos parâmetros a seguir ou uma combinação deles:
- nextHopGateway: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/gateways/default-internet-gateway: entrega pacotes para a Internet e as APIs e os serviços do Google.
- nextHopInstance: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME: envia pacotes para a interface de rede de uma instância de VM. Especifique a instância da VM por nome e zona. Se o destino da rota for um endereço IPv6, a instância da VM precisará ser pilha dupla.
- nextHopIp: ADDRESS: especifique um endereço IP de uma instância atual na rede VPC. Para rotas estáticas IPv6 (pré-lançamento), a instância precisa ser dual-stack. Para restrições importantes de URLs endereços IP do próximo salto, consulte Próximos saltos e .
- nextHopVpnTunnel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/vpnTunnels/VPN_TUNNEL_NAME: envia pacotes a um túnel da VPN clássica usando roteamento estático.
- nextHopIlb: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/forwardingRules/FORWARDING_RULE: envia pacotes para um balanceador de carga de rede de passagem interna. Especifique a regra de encaminhamento pelo nome (ou endereço IPv4 ou IPv6 (pré-lançamento)) e pela região. A versão IP da regra de encaminhamento especificada precisa corresponder à versão IP da rota estática criada.

Para fazer com que a rota estática personalizada se aplique somente às VMs selecionadas por tag de rede, adicione o campo tags e especifique uma ou mais tags de rede. Para saber mais informações sobre como as tags de rede e as rotas estáticas personalizadas funcionam juntas, consulte Rotas aplicáveis na visão geral de rotas. É possível usar tags com qualquer rota estática personalizada.

Para mais informações, consulte o método routes.insert.

Terraform

É possível criar uma rota estática usando um módulo Terraform.

Essa rota estática cria uma rota padrão para a Internet.

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

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

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

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

	return nil
}

Java


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

public class CreateRoute {

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

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

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

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

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

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

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

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

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

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

    wait_for_extended_operation(operation, "route creation")

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

Adicionar uma rota padrão do IPv4

A rota estática padrão IPv4 (0.0.0.0/0) com o next-hop-gateway definido como default-internet-gateway é configurada automaticamente para cada rede VPC. Use estas etapas para recriar essa rota, se necessário.

Console

No console do Google Cloud, acesse a página Rotas.

Acessar a página Rotas
Clique na guia Gerenciamento de rotas.
Clique em Criar rota.
Especifique um nome e uma descrição para a rota.
Selecione uma rede para a rota.
Em Intervalo de IP de destino, insira 0.0.0.0/0.
Especifique uma prioridade para a rota. A prioridade pode ser de 0 (a prioridade mais alta) a 65535 (a menor prioridade).
Em Próximo salto, selecione Gateway de Internet padrão.
Clique em Criar.

gcloud

Recrie a rota padrão do IPv4 para uma rede.

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

Substitua:

ROUTE_NAME: um nome para a rota
NETWORK: o nome da rede VPC que contém a rota

API

Recrie a rota padrão do IPv4 para uma rede.

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

Substitua:

PROJECT_ID: o ID do projeto em que sua rota é criada.
ROUTE_NAME: um nome para a rota
NETWORK_NAME: o nome da rede VPC que contém a rota

Adicionar uma rota padrão do IPv6

A rota estática padrão do IPv6 (::/0) com o next-hop-gateway definido como default-internet-gateway é automaticamente configurada para a rede VPC quando você cria uma sub-rede de pilha dupla com o elemento externo Tipo de acesso IP. É possível excluir a rota para bloquear todo o tráfego IPv6 de VMs para a Internet. É possível recriar a rota se necessário.

Console

No console do Google Cloud, acesse a página Rotas.

Acessar a página Rotas
Clique na guia Gerenciamento de rotas.
Clique em Criar rota.
Especifique um nome e uma descrição para a rota.
Selecione uma rede para a rota.
Em Intervalo de IP de destino, insira ::/0.
Especifique uma prioridade para a rota. A prioridade pode ser de 0 (a prioridade mais alta) a 65535 (a menor prioridade).
Em Próximo salto, selecione Gateway de Internet padrão.
Clique em Criar.

gcloud

Recrie a rota padrão do IPv6 para uma rede.

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

Substitua:

ROUTE_NAME: um nome para a rota.
NETWORK: o nome da rede VPC que contém a rota

API

Recrie a rota padrão do IPv6 para uma rede.

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

Substitua:

PROJECT_ID: o ID do projeto em que sua rota é criada.
ROUTE_NAME: um nome para a rota
NETWORK_NAME: o nome da rede VPC que contém a rota

Modificar uma rota estática

Não é possível editar ou atualizar uma rota estática depois de criá-la. Para modificar uma rota estática personalizada, é preciso excluí-la e criar uma substituição.

Excluir uma rota estática

Para excluir uma rota, faça o seguinte.

Console

No console do Google Cloud, acesse a página Rotas.

Acessar a página Rotas
Clique na guia Gerenciamento de rotas.
Marque a caixa de seleção ao lado da regra que você quer excluir.
Clique em Excluir.
Clique em Excluir novamente para confirmar.

gcloud

Exclua uma rota estática personalizada usando o seguinte comando da CLI gcloud:

gcloud compute routes delete ROUTE_NAME

Substitua ROUTE_NAME pelo nome da rota que você quer excluir.

API

Exclua uma rota estática personalizada para removê-la da rede VPC usando o método routes.delete:

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

Substitua:

PROJECT_ID: o ID do projeto em que sua rota está localizada.
ROUTE_NAME: o nome da rota a ser excluída.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java


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

public class DeleteRoute {

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

    deleteRoute(projectId, routeName);
  }

  // Deletes a route from a project.
  public static void deleteRoute(String projectId, String routeName)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (RoutesClient routesClient = RoutesClient.create()) {
      DeleteRouteRequest request = DeleteRouteRequest.newBuilder()
              .setProject(projectId)
              .setRoute(routeName)
              .setRequestId(UUID.randomUUID().toString())
              .build();
      routesClient.deleteCallable().futureCall(request).get(30, TimeUnit.SECONDS);
    }
  }
}

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    wait_for_extended_operation(operation, "route deletion")

Propagação de alterações de rota

Quando você adiciona ou exclui uma rota estática, ela é propagada para todas as regiões e instâncias de VM na sua rede VPC. Um status de operação de rota de PENDING ou RUNNING indica que a alteração de rota está na fila.

Depois de enfileirar, o status da operação de rota muda para DONE. Pode levar mais 30 segundos para que todas as instâncias de VM na sua rede VPC e em redes de peering de rede VPC usem uma nova rota ou parem de usar uma antiga.

Se você adicionar ou remover várias rotas estáticas simultaneamente, as alterações poderão ser aplicadas em qualquer ordem. Não há garantia de que a ordem em que você envia as alterações de rota será a ordem em que elas serão processadas. Instâncias diferentes podem se tornar conscientes das mudanças em momentos distintos.

Se você precisar fazer alterações de rota que dependam umas das outras, será necessário fazer essas alterações em sequência realizando alterações subsequentes somente após o status da alteração anterior ser DONE e depois de mais 30 segundos.

Ativar o encaminhamento de IP para instâncias

Por padrão, o encaminhamento de IP fica desativado, e o Google Cloud realiza uma verificação rigorosa de endereço de origem. Sujeita à configuração efetiva do firewall de saída, uma VM pode emitir pacotes com as seguintes origens:

O endereço IPv4 interno principal da interface de rede (NIC) de uma instância.
Qualquer intervalo de IP de alias configurado na NIC de uma instância.
Se um intervalo de endereços IPv6 estiver configurado na sub-rede e a instância for de pilha dupla, qualquer um dos endereços IPv6 atribuídos à NIC.
Um endereço IP interno ou externo associado a uma regra de encaminhamento, para balanceamento de carga de passagem ou encaminhamento de protocolo, se a instância for um back-end de um balanceador de carga de rede de passagem interna, um balanceador de carga de rede de passagem externa ou é referenciado por uma instância de destino.

Para usar uma VM como próximo salto de uma rota, a VM precisa encaminhar pacotes com origens que não correspondam a um dos endereços ou intervalos de IP na lista anterior. Para encaminhar pacotes com endereços de origem arbitrários, é preciso ativar o encaminhamento de IP:

Ao criar ou atualizar uma VM, ative o encaminhamento de IP seguindo as instruções nesta seção. A ativação do encaminhamento de IP se aplica a todas as NICs na VM.
Além das etapas nesta seção, ative o encaminhamento de IP no sistema operacional convidado da VM. Para fazer isso no Linux, defina o valor de um ou dos dois parâmetros de kernel a seguir como 1: net.ipv4.ip_forward (para IPv4) ou net.ipv6.conf.all.forwarding (para IPv6).

Para ativar o encaminhamento de IP ao criar uma VM, conclua as etapas a seguir.

Console

No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
Clique em Criar instância.
Na seção Opções avançadas, expanda Rede, discos, segurança, gerenciamento, locatário único.
Expanda a seção Rede.
Na seção Encaminhamento de IP, marque a caixa de seleção Ativar.

gcloud

Ao criar uma instância, adicione a sinalização --can-ip-forward ao seu comando:

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

API

Ao criar uma instância, use o campo canIpForward para ativar o encaminhamento de IP:

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

Substitua:

PROJECT_ID: o ID do projeto que contém a instância.
ZONE: a zona do Google Cloud que contém a instância.

Para mais informações, consulte o método instances.insert.

Terraform

Use o recurso Terraform para criar uma instância de VM com o encaminhamento de IP ativado.

Neste exemplo, os argumentos do Terraform receberam valores que você pode alterar.

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
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Depois de ativar o encaminhamento de IP, prossiga com o processo de criação da VM.

Para ativar o encaminhamento de IP em uma VM atual, atualize a propriedade da instância canIpForward.

A seguir

Para mais informações sobre rotas, consulte Rotas.
Para informações sobre as redes VPC do Google Cloud, consulte a Visão geral da nuvem privada virtual (VPC).
Para instruções sobre como criar e modificar redes VPC, consulte Criar e gerenciar redes VPC.