שימוש במסלולים

בדף הזה מוסבר איך ליצור ולנהל מסלולים לרשתות של ענן וירטואלי פרטי (VPC) ב- Google Cloud. בדף הזה מניחים שאתם מכירים את הסוגים השונים של Google Cloud מסלולים ואת המאפיינים שלהם, כפי שמתואר במאמר מסלולים.

לכל רשת חדשה יש שני סוגים של מסלולים שנוצרים על ידי המערכת: מסלול ברירת מחדל שאפשר להסיר או להחליף, ומסלול רשת משנה אחד לכל אחת מרשתות המשנה שלה. אי אפשר להסיר נתיב של רשת משנה אלא אם מוחקים את רשת המשנה עצמה.

בנוסף למסלולים שנוצרו על ידי המערכת, אפשר ליצור מסלולים סטטיים מותאמים אישית.

הצגת מסלולים לרשת VPC

אתם יכולים להשתמש ב-Google Cloud CLI או ב-API כדי להציג רשימה של פרטים על סוגי המסלולים הבאים:

פקודות ה-CLI של gcloud ושיטות ה-API לא מציגות את סוגי המסלולים הבאים:

כדי לראות את התצוגה המלאה של המסלול, משתמשים במסוף Google Cloud . כדי לראות רשימה של מסלולים מבוססי-מדיניות ותיאור שלהם, אפשר לעיין במאמר בנושא שימוש במסלולים מבוססי-מדיניות.

המסוף

נכנסים לדף Routes במסוף Google Cloud .

לדף Routes
בכרטיסייה Effective routes (מסלולים אפקטיביים), מבצעים את הפעולות הבאות:
- בוחרים רשת VPC.
- בוחרים אזור.
לוחצים על תצוגה.
אפשר לסנן לפי מאפיינים, כולל סוג המסלול, טווח כתובות ה-IP של היעד וסוג הניתוב הבא.
אופציונלי: לוחצים על המתג הצגת מסלולים שהוסתרו כדי להעביר אותו למצב מופעל ולראות את המסלולים שהוסתרו. כדי לראות את הסיבה להסתרת המסלול, מצביעים על הסמל בעמודה סטטוס.

gcloud

כדי לראות את רשימת המסלולים של רשתות המשנה והמסלולים הסטטיים ופרטים לגביהם, משתמשים בפקודות gcloud compute routes. הפקודות האלה לא מציגות סוגים אחרים של מסלולים. כדי לראות את כל המסלולים, משתמשים ב Google Cloud מסוף.

כדי להציג רשימת מסלולים:

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

כדי לקבל פרטים על מסלול:

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

מחליפים את מה שכתוב בשדות הבאים:

‫NETWORK_NAME: השם של רשת ה-VPC
‫PROJECT_ID: מזהה הפרויקט שמכיל את רשת ה-VPC
‫ROUTE_NAME: שם המסלול

API

כדי להציג רשימה של מסלולי רשת משנה ומסלולים סטטיים ופרטים שלהם, משתמשים בשיטות routes.list ו-routes.get. השיטות האלה לא מציגות סוגים אחרים של מסלולים. כדי לראות את כל המסלולים, משתמשים ב Google Cloud מסוף.

כדי להציג רשימת מסלולים:

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

כדי לקבל פרטים על מסלול:

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

מחליפים את מה שכתוב בשדות הבאים:

‫PROJECT_ID: מזהה הפרויקט שמכיל את רשת ה-VPC
‫NETWORK_URL: כתובת ה-URL של רשת ה-VPC
‫ROUTE_NAME: שם המסלול

רשימת מסלולים רלוונטיים לממשק רשת של מכונה וירטואלית

אפשר להשתמש במסוף Google Cloud כדי לראות את המסלולים הרלוונטיים לממשק הרשת של מכונה וירטואלית. בתצוגה הזו מוצגת רשימה מצומצמת של מסלולים שאפשר להשתמש בהם לתעבורת נתונים יוצאת.

כדי לראות את המסלולים הרלוונטיים לממשק רשת ספציפי של מכונה וירטואלית, פועלים לפי השלבים הבאים.

המסוף

נכנסים לדף VM instances במסוף Google Cloud .

כניסה לדף VM instances
מאתרים מכונה וירטואלית ברשימה. בתפריט More actions בסוף השורה, בוחרים באפשרות View network details.
אם למופע יש כמה ממשקי רשת, בקטע Network interface details בוחרים את ממשק הרשת שרוצים להציג.
בקטע Firewall and routes details, לוחצים על הכרטיסייה Routes כדי לראות את כל המסלולים שחלים על ממשק הרשת, ממוינים לפי שם המסלול.

הוספה והסרה של מסלולים סטטיים

אתם יכולים להוסיף או להסיר נתיבים סטטיים ונתיבים מבוססי-מדיניות שהם מקומיים לרשת ה-VPC. בקטע הזה מוסבר איך מוסיפים ומוחקים מסלולים סטטיים מקומיים. מידע נוסף על הוספה והסרה של מסלולים מבוססי-מדיניות זמין במאמר שימוש במסלולים מבוססי-מדיניות.

מסלולי רשת משנה מתווספים ונמחקים באופן אוטומטי כשמוסיפים או מוחקים רשת משנה. מידע נוסף על הוספה והסרה של רשתות משנה זמין במאמר עבודה עם רשתות משנה.

צריך לשנות את כל המסלולים ברשת VPC שמחוברת באמצעות קישור רשתות VPC ברשת ה-VPC שמייצאת את המסלולים האלה. מידע נוסף זמין במאמר בנושא אפשרויות להחלפת מסלולים.

לפני שמוסיפים נתיב סטטי

לפני שמוסיפים נתיב סטטי, חשוב לשים לב לנקודות הבאות:

חשוב להבין את הסוגים השונים של קפיצות לכתובת הבאה שאפשר להשתמש בהן בניתוב סטטי. במאמר Next hops and features אפשר לקרוא מידע על הסוגים השונים של קפיצות סטטיות בנתיב, כולל אילו מהן תומכות ביעדי IPv6.
אלא אם משתמשים ברשתות משנה היברידיות, מסלול סטטי לא יכול לכלול טווח יעד שתואם לטווח היעד של רשת משנה או של מסלול רשת משנה בחיבור peering, או ספציפי יותר ממנו. פרטים נוספים מופיעים במאמר אינטראקציות עם מסלולים סטטיים בהתאמה אישית בסקירה הכללית על מסלולים ובמאמר אינטראקציות בין רשתות משנה ומסלולים סטטיים במסמכי התיעוד בנושא VPC Network Peering.
כדי למנוע התנגשויות כשמשתמשים ברשת VPC במצב אוטומטי, לא כדאי ליצור מסלולים סטטיים שהיעדים שלהם מתאימים ל-10.128.0.0/9. פרטים נוספים זמינים במאמר בנושא טווחים של כתובות IPv4 במצב אוטומטי.
היעדים של מסלולים סטטיים מותאמים אישית לא יכולים לחפוף לטווח שהוקצה פנימי.
לפני שיוצרים נתיב סטטי מותאם אישית שמשתמש במכונה וירטואלית כנקודת הקפיצה הבאה, חשוב להכיר את המונח 'מופעים כנקודות קפיצה הבאות'. Google Cloud המערכת מאמתת את קיומה של מכונה וירטואלית רק בזמן שיוצרים את הנתיב, אם בוחרים במופע של נקודת הקפיצה הבאה.
אם יוצרים מסלול באמצעות תג רשת, רק מכונות וירטואליות עם התג הזה מקבלות את המסלול. עם זאת, מכונות וירטואליות מתויגות עדיין מקבלות את כל המסלולים שלא כוללים תג רשת.

הערה: עבור קפיצות הבאות שמשתמשות ב-Cloud Router, אפשר להשתמש במסלולים שנלמדו בהתאמה אישית כחלופה למסלולים סטטיים. בניגוד למסלולים סטטיים, מסלולים שנלמדו בהתאמה אישית מושבתים אוטומטית אם יש שיבוש בסשן BGP המשויך שלהם. התנהגות זו מאפשרת להשתמש במסלולים חלופיים במקרה של הפסקת שירות ברשת, ועשויה למנוע את השמטת התנועה. בנוסף, בניגוד למסלולים סטטיים, אפשר להשתמש במסלולים מותאמים אישית שנלמדו באמצעות חיבורי VLAN של Cloud Interconnect ומנהרות HA VPN. מידע נוסף זמין במאמר בנושא מסלולים שנלמדו בהתאמה אישית. התכונה הזו נמצאת בגרסת טרום-השקה.

הוספת נתיב סטטי

הוספת מסלול סטטי לרשת. למידע נוסף על סוגים שונים של קפיצות הבאות בניתוב סטטי, כולל אילו מהן תומכות ביעדי IPv6, אפשר לעיין במאמר בנושא קפיצות הבאות ותכונות.

המסוף

נכנסים לדף Routes במסוף Google Cloud .

לדף Routes
לוחצים על הכרטיסייה ניהול נתיבים.
לוחצים על יצירת מסלול.
מציינים שם ותיאור לנתיב.
ברשימה Network, בוחרים רשת קיימת עבור המסלול.
ברשימה סוג המסלול, בוחרים באפשרות מסלול סטטי.
ברשימה IP version בוחרים את גרסת ה-IP הנדרשת:
- כדי ליצור נתיב סטטי של IPv4, בוחרים באפשרות IPv4.
- כדי ליצור נתיב סטטי של IPv6, בוחרים באפשרות IPv6.
מציינים טווח כתובות IP של יעד. היעד הרחב ביותר האפשרי הוא 0.0.0.0/0 ל-IPv4 או ::/0 ל-IPv6.
מציינים עדיפות למסלול. העדיפות יכולה להיות מ-0 (העדיפות הגבוהה ביותר) עד 65535 (העדיפות הנמוכה ביותר).
כדי שהניתוב יחול רק על מקרים נבחרים עם תגי רשת תואמים, מציינים את התגים האלה בשדה תגי מופעים. משאירים את השדה ריק כדי שהנתיב יחול על כל המופעים ברשת.
בוחרים next hop בשביל המסלול:
- שער ברירת המחדל באינטרנט: מעביר חבילות לאינטרנט ולממשקי API ולשירותים של Google
- ציון מכונה: העברת מנות לממשק הרשת של מכונה וירטואלית. מציינים את מכונת ה-VM לפי שם ותחום. אם יעד המסלול הוא כתובת IPv6, המכונה הווירטואלית צריכה להיות dual-stack או IPv6-only.
- ציון כתובת IP של מכונה: מציינים כתובת IP של מכונה קיימת ברשת ה-VPC. במקרה של מסלולים סטטיים של IPv6, המכונה צריכה להיות dual-stack או IPv6-only. מידע על הגבלות חשובות לגבי כתובות IP תקפות של הנתב הבא זמין במאמר הנתבים הבאים של מסלול סטטי.
- הגדרת מנהרת VPN: העברת מנות למנהרת VPN קלאסי קיימת באמצעות ניתוב סטטי.
- מציינים כלל העברה של מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי: מעביר חבילות אל מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי שמוגדר לפי השם והאזור של כלל ההעברה הפנימי שלו. כלל ההעברה יכול לכלול כתובת IPv4 או IPv6. גרסת ה-IP של כלל ההעברה שאתם מציינים צריכה להיות זהה לגרסת ה-IP של המסלול הסטטי שאתם יוצרים.
לוחצים על יצירה.

gcloud

כדי ליצור נתיב סטטי מותאם אישית חדש, מריצים את הפקודה הבאה ב-CLI של gcloud:

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

מחליפים את מה שכתוב בשדות הבאים:

‫ROUTE_NAME: שם המסלול
‫NETWORK: השם של רשת ה-VPC שמכילה את המסלול
‫DESTINATION_RANGE: כתובות היעד של IPv4 או IPv6 שאליהן המסלול הזה חל. היעד הרחב ביותר האפשרי הוא 0.0.0.0/0 ל-IPv4 או ::/0 ל-IPv6.
‫PRIORITY: העדיפות של המסלול, שיכולה להיות מ-0 (העדיפות הכי גבוהה) עד 65535 (העדיפות הכי נמוכה)
‫NEXT_HOP_SPECIFICATION: הצעד הבא במסלול הסטטי. אפשר להשתמש באחד מהפרמטרים הבאים או בשילוב של כמה מהם:
- ‫--next-hop-gateway=default-internet-gateway: העברת מנות לאינטרנט ולממשקי API ולשירותים של Google.
- ‫--next-hop-instance=INSTANCE_NAME ו---next-hop-instance-zone=ZONE: העברת מנות לממשק רשת של מכונה וירטואלית קיימת. מציינים את מכונת ה-VM לפי שם ואזור. אם יעד המסלול הוא כתובת IPv6, המכונה הווירטואלית צריכה להיות dual-stack או IPv6-only.
- ‫--next-hop-address=ADDRESS: מציינים כתובת IP של מכונה קיימת ברשת ה-VPC. במקרה של נתיבים סטטיים של IPv6, המכונה צריכה להיות dual-stack או IPv6-only. הגבלות חשובות לגבי כתובות IP תקפות של קפיצות הבאות מפורטות במאמר קפיצות הבאות ותכונות.
- ‫--next-hop-vpn-tunnel=VPN_TUNNEL_NAME ו---next-hop-vpn-tunnel-region=REGION: העברת מנות לטונל VPN קלאסי קיים באמצעות ניתוב סטטי.
- ‫--next-hop-ilb=FORWARDING_RULE ו---next-hop-ilb-region=REGION: העברת חבילות נתונים אל מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי. מציינים את כלל ההעברה לפי השם (או כתובת IPv4 או IPv6) והאזור. גירסת ה-IP של כלל ההעברה שאתם מציינים צריכה להיות זהה לגירסת ה-IP של המסלול הקבוע שאתם יוצרים. למידע נוסף על הגדרת מסלולים סטטיים למאזנים פנימיים של עומסי רשת להעברת סיגנל ללא שינוי, אפשר לעיין במאמר בנושא יצירת מסלולים סטטיים.
כדי שהנתיב הסטטי המותאם אישית יחול רק על מכונות וירטואליות נבחרות באמצעות תג רשת, מוסיפים את הדגל --tags ומציינים תג רשת אחד או יותר. מידע נוסף על האופן שבו תגי רשת ומסלולים סטטיים מותאמים אישית פועלים יחד זמין במאמר מסלולים רלוונטיים בסקירה הכללית בנושא מסלולים. אפשר להשתמש בתגים עם כל נתיב סטטי מותאם אישית.

מידע נוסף על התחביר של ה-CLI של gcloud זמין במסמכי התיעוד של SDK.

API

יוצרים נתיב סטטי מותאם אישית חדש.

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

מחליפים את מה שכתוב בשדות הבאים:

‫PROJECT_ID: מזהה הפרויקט שבו נוצר המסלול
‫ROUTE_NAME: שם המסלול
‫NETWORK: השם של רשת ה-VPC שמכילה את המסלול.
‫DESTINATION_RANGE: טווח כתובות היעד של IPv4 או IPv6 שאליו המסלול הזה חל. היעד הרחב ביותר האפשרי הוא 0.0.0.0/0 ל-IPv4 או ::/0 ל-IPv6.
‫PRIORITY: העדיפות של המסלול, שיכולה להיות מ-0 (העדיפות הכי גבוהה) עד 65535 (העדיפות הכי נמוכה)
‫NEXT_HOP_SPECIFICATION: הניתוב הבא של המסלול הסטטי. אפשר להשתמש באחד מהפרמטרים הבאים או בשילוב של פרמטרים:
- ‫nextHopGateway: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/gateways/default-internet-gateway: מעביר מנות לאינטרנט ול-Google APIs ולשירותים של Google
- nextHopInstance: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME: מעביר חבילות נתונים לממשק הרשת של מכונה וירטואלית. מציינים את המכונה הווירטואלית לפי שם ואזור. אם יעד המסלול הוא כתובת IPv6, המכונה הווירטואלית צריכה להיות dual-stack או IPv6-only.
- ‫nextHopIp: ADDRESS: מציינים כתובת IP של מכונה קיימת ברשת ה-VPC. במקרה של מסלולים סטטיים של IPv6, המכונה צריכה להיות dual-stack או IPv6-only. מידע על הגבלות חשובות לגבי כתובות IP חוקיות של קפיצות הבאות זמין במאמר קפיצות הבאות ותכונות.
- ‫nextHopVpnTunnel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/vpnTunnels/VPN_TUNNEL_NAME: מעביר מנות ל-Classic VPN קיים במנהרה באמצעות ניתוב סטטי.
- ‫nextHopIlb: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/forwardingRules/FORWARDING_RULE: מעביר מנות למאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי. מציינים את כלל ההעברה לפי השם (או כתובת IPv4 או IPv6) והאזור. גירסת ה-IP של כלל ההעברה שאתם מציינים צריכה להיות זהה לגירסת ה-IP של המסלול הקבוע שאתם יוצרים.

כדי שהניתוב הסטטי המותאם אישית יחול רק על מכונות וירטואליות נבחרות באמצעות תג רשת, מוסיפים את השדה tags ומציינים תג רשת אחד או יותר. מידע נוסף על האופן שבו תגי רשת ומסלולים סטטיים מותאמים אישית פועלים יחד זמין במאמר מסלולים רלוונטיים בסקירה הכללית בנושא מסלולים. אפשר להשתמש בתגים עם כל נתיב סטטי מותאם אישית.

מידע נוסף זמין במאמר על השיטה routes.insert.

Terraform

אפשר ליצור נתיב סטטי באמצעות מודול של Terraform.

המסלול הסטטי הזה יוצר מסלול ברירת מחדל לאינטרנט.

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

כדי ללמוד איך להחיל הגדרות ב-Terraform או להסיר אותן, ראו פקודות בסיסיות ב-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)

הוספת נתיב ברירת מחדל של IPv4

מסלול סטטי שמוגדר כברירת מחדל ב-IPv4‏ (0.0.0.0/0) עם next-hop-gateway שמוגדר ל-default-internet-gateway מוגדר באופן אוטומטי לכל רשת VPC. אם צריך, אפשר ליצור מחדש את המסלול הזה לפי השלבים הבאים.

המסוף

נכנסים לדף Routes במסוף Google Cloud .

לדף Routes
לוחצים על הכרטיסייה ניהול נתיבים.
לוחצים על יצירת מסלול.
מציינים שם ותיאור לנתיב.
בוחרים רשת קיימת למסלול.
בשדה טווח כתובות ה-IP של היעד, מזינים 0.0.0.0/0.
מציינים עדיפות למסלול. העדיפות יכולה להיות מ-0 (העדיפות הגבוהה ביותר) עד 65535 (העדיפות הנמוכה ביותר).
בקטע הניתוב הבא, בוחרים באפשרות שער ברירת המחדל באינטרנט.
לוחצים על יצירה.

gcloud

יצירה מחדש של נתיב ברירת המחדל של IPv4 לרשת.

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

מחליפים את מה שכתוב בשדות הבאים:

‫ROUTE_NAME: שם למסלול
‫NETWORK: השם של רשת ה-VPC שמכילה את המסלול

API

יצירה מחדש של נתיב ברירת המחדל של IPv4 לרשת.

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

מחליפים את מה שכתוב בשדות הבאים:

‫PROJECT_ID: מזהה הפרויקט שבו נוצר המסלול
‫ROUTE_NAME: שם למסלול
‫NETWORK_NAME: השם של רשת ה-VPC שמכילה את המסלול

הוספת מסלול ברירת מחדל של IPv6

כשיוצרים רשת משנה עם סוג הגישה IPv6 שמוגדר כחיצוני, מוגדרת אוטומטית רשת VPC עם מסלול סטטי שמוגדר כברירת מחדל ל-IPv6 ‏ (::/0) עם next-hop-gateway שמוגדר כ-default-internet-gateway. אפשר למחוק את המסלול כדי לחסום את כל התנועה של IPv6 ממכונות וירטואליות לאינטרנט. אפשר גם ליצור מחדש את המסלול אם צריך.

המסוף

נכנסים לדף Routes במסוף Google Cloud .

לדף Routes
לוחצים על הכרטיסייה ניהול נתיבים.
לוחצים על יצירת מסלול.
מציינים שם ותיאור לנתיב.
בוחרים רשת קיימת למסלול.
בשדה טווח כתובות ה-IP של היעד, מזינים ::/0.
מציינים עדיפות למסלול. העדיפות יכולה להיות מ-0 (העדיפות הגבוהה ביותר) עד 65535 (העדיפות הנמוכה ביותר).
בקטע הניתוב הבא, בוחרים באפשרות שער ברירת המחדל באינטרנט.
לוחצים על יצירה.

gcloud

יצירה מחדש של נתיב ברירת המחדל של IPv6 לרשת.

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

מחליפים את מה שכתוב בשדות הבאים:

‫ROUTE_NAME: שם המסלול.
‫NETWORK: השם של רשת ה-VPC שמכילה את המסלול.

API

יצירה מחדש של נתיב ברירת המחדל של IPv6 לרשת.

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

מחליפים את מה שכתוב בשדות הבאים:

‫PROJECT_ID: מזהה הפרויקט שבו נוצר המסלול
‫ROUTE_NAME: שם למסלול
‫NETWORK_NAME: השם של רשת ה-VPC שמכילה את המסלול

שינוי של נתיב סטטי

אי אפשר לערוך או לעדכן נתיב סטטי אחרי שיוצרים אותו. כדי לשנות מסלול סטטי, צריך למחוק אותו וליצור מסלול חדש במקומו.

מחיקת מסלול סטטי

כדי למחוק מסלול:

המסוף

נכנסים לדף Routes במסוף Google Cloud .

לדף Routes
לוחצים על הכרטיסייה ניהול נתיבים.
מסמנים את תיבת הסימון לצד הכלל שרוצים למחוק.
לוחצים על מחיקה.
לוחצים שוב על מחיקה כדי לאשר את הפעולה.

gcloud

כדי למחוק נתיב סטטי בהתאמה אישית, משתמשים בפקודה הבאה ב-CLI של gcloud:

gcloud compute routes delete ROUTE_NAME

מחליפים את ROUTE_NAME בשם של המסלול שרוצים למחוק.

API

כדי למחוק מסלול סטטי בהתאמה אישית ולהסיר אותו מרשת ה-VPC, משתמשים בשיטה routes.delete:

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

מחליפים את מה שכתוב בשדות הבאים:

‫PROJECT_ID: מזהה הפרויקט שבו נמצא המסלול.
‫ROUTE_NAME: שם המסלול שרוצים למחוק.

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

הפצה של שינויים במסלולים

כשמוסיפים או מוחקים נתיב סטטי, הנתיב מועבר לכל האזורים ולכל המכונות הווירטואליות ברשת ה-VPC. סטטוס של פעולת ניתוב PENDING או RUNNING מציין שהשינוי במסלול נמצא בתור.

אחרי ההוספה לתור, סטטוס הפעולה של המסלול משתנה לDONE. יכול להיות שיחלפו עוד 30 שניות עד שכל ה-VM ברשת ה-VPC וברשתות ה-VPC שמקושרות לרשתות שכנות (peering) ישתמשו במסלול חדש או יפסיקו להשתמש במסלול ישן.

אם מוסיפים או מסירים כמה נתיבים סטטיים בו-זמנית, השינויים יכולים להתבצע בכל סדר. אין ערובה לכך שהסדר שבו שולחים שינויים במסלולים הוא הסדר שבו הם מעובדים. יכול להיות שמופעים שונים יזהו את השינויים בזמנים שונים.

אם אתם צריכים לבצע שינויים במסלולים שתלויים זה בזה, אתם צריכים לבצע את השינויים האלה ברצף. כלומר, לבצע שינוי רק אחרי שהסטטוס של השינוי הקודם הוא DONE ועברו עוד 30 שניות.

הפעלת העברת IP למופעים

כברירת מחדל, העברת כתובות IP מושבתת, ו- Google Cloud מבצע בדיקה קפדנית של כתובת המקור. בהתאם להגדרת חומת האש ליציאה, מכונת VM יכולה לשלוח חבילות עם המקורות הבאים:

כתובת ה-IPv4 הפנימית הראשית של ממשק הרשת (NIC) של מכונה.
כל טווח כתובות IP של כינוי שהוגדר בכרטיס ה-NIC של מופע.
אם מוגדר טווח כתובות IPv6 ברשת המשנה, והמכונה היא בעלת מחסנית כפולה או IPv6 בלבד, כל אחת מכתובות ה-IPv6 שמוקצות ל-NIC.
כתובת IP פנימית או כתובת IP חיצונית שמשויכת לכלל העברה, לאיזון עומסים מסוג pass-through או להעברת פרוטוקול, אם המופע הוא קצה עורפי של מאזן עומסי רשת פנימי מסוג pass-through, מאזן עומסי רשת חיצוני מסוג pass-through או אם יש הפניה אליו ממופע יעד.

כדי להשתמש במכונה וירטואלית כצעד הבא במסלול, המכונה הווירטואלית צריכה להעביר מנות שהמקורות שלהן לא תואמים לאף אחת מכתובות ה-IP או מהטווחים ברשימה הקודמת. כדי להעביר חבילות עם כתובות מקור שרירותיות, צריך להפעיל העברת IP:

כשיוצרים או מעדכנים מכונה וירטואלית, מפעילים את העברת ה-IP לפי ההוראות שבקטע הזה. הפעלת העברת כתובות IP חלה על כל כרטיסי ה-NIC במכונת ה-VM.
בנוסף לשלבים שמפורטים בקטע הזה, צריך להפעיל העברת IP במערכת ההפעלה האורחת של מכונת ה-VM. כדי לעשות את זה ב-Linux, מגדירים את הערך של אחד מפרמטרים הקרנל הבאים או של שניהם ל-1 (ל-IPv4) או ל-net.ipv6.conf.all.forwarding (ל-IPv6):net.ipv4.ip_forward

כדי להפעיל העברת IP כשיוצרים מכונה וירטואלית, מבצעים את השלבים הבאים.

המסוף

נכנסים לדף VM instances במסוף Google Cloud .

כניסה לדף VM instances
לוחצים על Create instance.
בקטע Advanced options, מרחיבים את האפשרות Networking, disks, security, management, sole-tenancy.
מרחיבים את הקטע Networking.
בקטע IP forwarding, מסמנים את תיבת הסימון Enable.

gcloud

כשיוצרים מכונה, מוסיפים את הדגל --can-ip-forward לפקודה:

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

API

כשיוצרים מכונה, משתמשים בשדה canIpForward כדי להפעיל העברת IP:

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

מחליפים את מה שכתוב בשדות הבאים:

‫PROJECT_ID: המזהה של הפרויקט שמכיל את המכונה
‫ZONE: Google Cloud האזור שבו נמצאת המכונה

מידע נוסף זמין במאמר בנושא השיטה instances.insert.

Terraform

אתם יכולים להשתמש במשאב של Terraform כדי ליצור מכונה וירטואלית עם הפעלת העברת IP.

בדוגמה הזו, הארגומנטים של Terraform קיבלו ערכים שאפשר לשנות.

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
}

כדי ללמוד איך להחיל הגדרות ב-Terraform או להסיר אותן, ראו פקודות בסיסיות ב-Terraform.

אחרי שמפעילים את העברת ה-IP, ממשיכים בתהליך יצירת המכונה הווירטואלית.

כדי להפעיל העברת IP במכונה וירטואלית קיימת, מעדכנים את מאפיין המכונה canIpForward.

המאמרים הבאים

מידע על מסלולים זמין במאמר מסלולים.
מידע על רשתות VPC זמין במאמר סקירה כללית על ענן וירטואלי פרטי (VPC). Google Cloud
הוראות ליצירה ושינוי של רשתות VPC זמינות במאמר יצירה וניהול של רשתות VPC.