יצירה והרצה של בדיקות קישוריות

כדי להריץ בדיקות קישוריות, פועלים לפי השלבים שבדף הזה.

במאמר עדכון או מחיקה של בדיקות מוסבר איך לערוך או למחוק בדיקה אחת או יותר.

מידע נוסף על בדיקות קישוריות זמין בסקירה הכללית.

לפני שמתחילים

כדי להשתמש בבדיקות קישוריות, צריך להגדיר את הפריטים הבאים ב- Google Cloud:

1. נכנסים לדף לבחירת הפרויקט במסוף Google Cloud .

   מעבר לדף לבחירת הפרויקט

   בוחרים או יוצרים Google Cloud פרויקט.

2. מוודאים שהחיוב מופעל בפרויקט Google Cloud .

3. מתקינים את Google Cloud CLI, שהוא חלק מ-Google Cloud CLI. כדי להתקין את הגרסה העדכנית של ה-CLI של gcloud, אפשר לעיין במסמכי התיעוד של CLI של gcloud.

   רשימה של כל הפקודות מופיעה במאמרי העזרה בנושא הפקודה gcloud.

4. מפעילים את Network Management API. הפעלת ה-API מספקת לכם את האפשרויות הבאות:

   • דוגמאות לקריאות ל-API שמשתמשות ב-Network Management API

     אפשר לבדוק פקודות של Network Management API באמצעות API Explorer. במסמך ההפניה Network Management API, אפשר להשתמש בעמודה Try this API כדי לבדוק שדות API ולהריץ בדיקה.

   • קוד לדוגמה שמשתמש בלקוח Python של ה-API

     קוד הדוגמה מניח שיצרתם משאב בשם api כדי לקיים אינטראקציה עם Network Management API. כדי ליצור משאב, משתמשים בפונקציה build. מקרה לדוגמה:

     from googleapiclient.discovery import build
     api = build('networkmanagement', 'v1')
     

     מידע נוסף על לקוח Python של API זמין במקורות הבאים:

     • מסמכי התיעוד של ספריית הלקוח של Google API ל-Python ב-GitHub, כולל הוראות להתקנה ולאימות.
     • מאמרי העזרה של Network Management API ללקוח Python של ה-API.
5. קבלת ההרשאות שנדרשות להרצה ולצפייה בבדיקות. פרטים נוספים זמינים במאמר בנושא הקצאת גישה.

הרצת בדיקות קישוריות

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

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

ממסוף Google Cloud , אפשר להריץ בדיקות קישוריות באחת מהדרכים הבאות:

• הדף Connectivity Tests (בדיקות קישוריות), שאפשר לגשת אליו מהתפריט Networking > Network Intelligence Center (רשת > מרכז המידע על הרשת).

• הדף Network interface details של ממשק רשת של מכונה וירטואלית (VM) ב-Compute Engine. אם משתמשים בדף הזה, צריך להשתמש בממשק הרשת הנוכחי כמקור או כיעד של הבדיקה. בדף הזה מפורטות רק בדיקות שרלוונטיות לממשק הרשת הנוכחי.

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

כדי לבדוק את הסטטוס של פעולת בדיקה בזמן שהפעולה פועלת, אפשר לעיין במאמר בנושא בדיקת פעולת בדיקה שפועלת. דוגמאות לפעולות בדיקה: create ו-rerun.

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

שיטות מומלצות

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

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

בדיקה אל מכונה וירטואלית או ממכונה וירטואלית עם כמה ממשקי רשת

בקטע הזה מוסבר איך לבצע בדיקה אל או מתוך ממשק רשת לא ראשי של מכונה וירטואלית.

המסוף

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

אפשר גם להריץ בדיקה מהדף Network interface details (פרטי ממשק הרשת) של ממשק רשת של מכונה וירטואלית ב-Compute Engine. אם משתמשים בדף הזה, צריך להשתמש בממשק הרשת הנוכחי כמקור או כיעד של הבדיקה.

‫gcloud ו-API

צריך לציין את ממשק הרשת שבו רוצים להשתמש לבדיקה באחת מהדרכים הבאות:

• כתובת IP ו-URI של הרשת
• כתובת IP ו-URI של מכונה וירטואלית
• ‫URI של רשת ו-URI של מכונה וירטואלית

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

הצגת רשימה של כל הבדיקות בפרויקט

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. בחלק העליון של הדף, בתפריט הנפתח של הפרויקט, בוחרים פרויקט.
3. הדף בדיקות קישוריות מתרענן ומוצגות בו הבדיקות של הפרויקט.

gcloud

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

  gcloud network-management connectivity-tests list

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

  gcloud network-management connectivity-tests list --project=PROJECT_ID

API

כדי להציג רשימה של כל הבדיקות הקיימות שבבעלות פרויקט, משתמשים בשיטה projects.locations.global.connectivityTests.list.

GET https://networkmanagement.googleapis.com/v1/{parent=projects/PROJECT_ID/locations/global}/connectivityTests

• מחליפים את PROJECT_ID במזהה הפרויקט שמכיל את הבדיקות שרוצים להציג ברשימה.

Python

בדוגמה הבאה של קוד מוצגת רשימה של כל הבדיקות הקיימות שבבעלות פרויקט. מידע נוסף זמין במאמר בנושא list בספריית הלקוח של Google API ל-Python.

project_id = "PROJECT_ID"
parent = 'projects/%s/locations/global' % project_id
request = api.projects().locations().global_().connectivityTests().list(parent=parent)

print(json.dumps(request.execute(), indent=4))

מחליפים את PROJECT_ID במזהה הפרויקט שמכיל את הבדיקות שרוצים להציג ברשימה.

בדיקה בין מכונות וירטואליות ברשת VPC

ההנחיות האלה מניחות ששתי המכונות הווירטואליות נמצאות באותו Google Cloud פרויקט.

המסוף

מדף בדיקות הקישוריות הראשי

1. נכנסים לדף בדיקות קישוריות במסוף Google Cloud .

   כניסה לדף בדיקות קישוריות

   שאר השלבים יופיעו באופן אוטומטי במסוף. Google Cloud

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint, בוחרים באפשרות VM instance.
   2. בתפריט Source VM instance (מכונה וירטואלית של המקור), בוחרים את המכונה הווירטואלית הספציפית של המקור.

   3. בתפריט Source network interface (ממשק רשת של מקור), בוחרים את ממשק הרשת.

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

   4. אופציונלי: בוחרים את כתובת ה-IP של המקור מהרשימה. ברירת המחדל היא כתובת ה-IP של מכונת ה-VM שממנה מגיעה הבקשה.
6. בקטע יעד, מבצעים את הפעולות הבאות:
   1. בתפריט Destination endpoint (נקודת קצה של היעד), בוחרים באפשרות VM instance (מופע של מכונה וירטואלית).
   2. בתפריט Destination VM instance, בוחרים את מופע מכונת ה-VM הספציפי של היעד.

   3. בתפריט Destination network interface (ממשק רשת יעד), בוחרים את ממשק הרשת.

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

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

הערה: במכונת dual-stack, כתובת ה-IP של המקור וכתובת ה-IP של היעד חייבות להיות מאותו סוג. לדוגמה, אי אפשר לבצע בדיקה ממכונה וירטואלית עם כתובת IPv4 למכונה וירטואלית עם כתובת IPv6.

7. בשדה יעד לניוד, מזינים יעד לניוד.
8. לוחצים על יצירה.

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

מדף הפרטים של ממשק הרשת

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

   כניסה לדף VM instances

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

4. בקטע Network interfaces (ממשקי רשת), בוחרים את ממשק הרשת שרוצים להשתמש בו כדי להריץ בדיקה.

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

5. בקטע Network analysis (ניתוח רשת), לוחצים על Create Connectivity Test (יצירת בדיקת קישוריות) ומבצעים את הפעולות הבאות:

   1. בשדה שם הבדיקה, מזינים שם לבדיקה.
   2. ברשימה Protocol, בוחרים פרוטוקול.

   3. בשדה מקור, אפשר לבחור באפשרות ממשק הרשת הנוכחי או באפשרות אחר.

      אם בוחרים באפשרות ממשק הרשת הנוכחי, צריך לפעול באופן הבא:

      1. בתפריט Destination endpoint (נקודת קצה של היעד), בוחרים באפשרות VM instance (מופע של מכונה וירטואלית).
      2. בתפריט Destination VM instance (מכונת VM ליעד), בוחרים את המכונה.
      3. בתפריט Destination network interface (ממשק רשת יעד), בוחרים את ממשק הרשת.
      4. אופציונלי: בוחרים את כתובת ה-IP של היעד. ברירת המחדל היא כתובת ה-IP של מכונת היעד.

      אם בוחרים באפשרות אחר, צריך לפעול באופן הבא:

      1. בתפריט Source endpoint, בוחרים באפשרות VM instance.
      2. בתפריט Source VM instance, בוחרים את המכונה.
      3. בתפריט Source network interface (ממשק רשת של מקור), בוחרים את ממשק הרשת.
      4. אופציונלי: בוחרים כתובת IP של המקור. ברירת המחדל היא כתובת ה-IP של מכונת ה-VM שממנה מגיעה הבקשה.

   4. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

   5. לוחצים על יצירה.

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

gcloud

מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC.

gcloud network-management connectivity-tests create NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --destination-instance=DESTINATION_INSTANCE \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Terraform

אתם יכולים להשתמש במשאב של Terraform כדי ליצור בדיקה בין שתי מכונות וירטואליות ברשת VPC.

resource "google_network_management_connectivity_test" "instance_test" {
  name = "conn-test-instances"
  source {
    instance = google_compute_instance.source.id
  }

  destination {
    instance = google_compute_instance.destination.id
    port     = "80"
  }

  protocol = "TCP"
}

resource "google_compute_instance" "source" {
  name         = "source-vm"
  machine_type = "e2-medium"

  boot_disk {
    initialize_params {
      image = data.google_compute_image.debian_9.id
    }
  }

  network_interface {
    network = "default"
    access_config {
    }
  }
}

resource "google_compute_instance" "destination" {
  name         = "dest-vm"
  machine_type = "e2-medium"

  boot_disk {
    initialize_params {
      image = data.google_compute_image.debian_9.id
    }
  }

  network_interface {
    network = "default"
    access_config {
    }
  }
}

data "google_compute_image" "debian_9" {
  family  = "debian-11"
  project = "debian-cloud"
}

API

בבדיקה לדוגמה הבאה נקבע אם הגדרת הרשת הקיימת מאפשרת למכונה וירטואלית instance1 לשלוח פינג למכונה וירטואלית instance2.

משתמשים בשיטה projects.locations.global.connectivityTests.create.

 POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
   {
     "source": {
       "instance": "SOURCE_INSTANCE",
       "ipAddress": "SOURCE_IP_ADDRESS",
     },
     "destination": {
       "instance": "DESTINATION_INSTANCE",
       "ipAddress": "DESTINATION_IP_ADDRESS",
     },
     "protocol": "PROTOCOL",
   }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

קוד הדוגמה הבא יוצר בדיקה בין שתי מכונות וירטואליות. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "instance":
          "SOURCE_INSTANCE",
      "ipAddress":
          "SOURCE_IP_ADDRESS",
      "projectId":
          "SOURCE_INSTANCE_PROJECT_ID"
  },
  "destination": {
      "instance":
          "DESTINATION_INSTANCE",
      "ipAddress":
          "DESTINATION_IP_ADDRESS",
      "projectId":
          "DESTINATION_INSTANCE_PROJECT_ID"
  },
  "protocol":
      "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫SOURCE_INSTANCE_PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫DESTINATION_INSTANCE_PROJECT_ID: מזהה הפרויקט של מכונת היעד.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה בין כתובות IP פרטיות ברשת VPC

בדוגמה הזו, מניחים ששתי כתובות ה-IP הן כתובות IP פרטיות באותה רשת VPC.

המסוף

1. נכנסים לדף בדיקות קישוריות במסוף Google Cloud .

   מעבר אל בדיקות קישוריות

   שאר השלבים יופיעו במסוף. Google Cloud

2. לוחצים על יצירת בדיקת קישוריות.

3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.

5. בקטע מקור, מבצעים את הפעולות הבאות:

   1. ברשימה Source endpoint בוחרים באפשרות IP address.
   2. בשדה כתובת ה-IP של המקור, מזינים את כתובת ה-IP של המקור.
   3. ברשימה סוג כתובת ה-IP, בוחרים את סוג כתובת ה-IP.

6. בקטע יעד, מבצעים את הפעולות הבאות:

   1. ברשימה Destination endpoint, בוחרים באפשרות IP address.
   2. בשדה כתובת IP של היעד, מזינים את כתובת ה-IP של היעד.
7. בשדה יציאת יעד, מזינים מספר יציאת יעד תקין. המספר חייב להיות בין 0 ל-65535, כולל.
8. לוחצים על יצירה.

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

gcloud

מחליפים את המשתנים באפשרויות הפקודה בערכים מרשת ה-VPC.

gcloud network-management connectivity-tests create NAME \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --source-network=SOURCE_NETWORK \
    --source-network-type=GCP_NETWORK \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור, לדוגמה: projects/myproject/global/networks/default.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

gcloud network-management connectivity-tests create NAME \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --source-network=SOURCE_NETWORK \
    --source-network-type=GCP_NETWORK \
    --destination-instance=DESTINATION_INSTANCE  \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור. לדוגמה: projects/myproject/global/networks/default.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

כשמציינים כתובת IP של מקור שהיא כתובת IP חיצונית מחוץ ל- Google Cloud, צריך להגדיר את הפרמטר networkType לערך INTERNET. מחליפים את הערכים בפקודה הבאה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --source-network-type=INTERNET \
    --destination-ip-address= DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Terraform

אתם יכולים להשתמש במשאב של Terraform כדי ליצור בדיקה בין שתי כתובות IP ברשת VPC.

אין צורך לאשר אם כתובת ה-IP שלכם נמצאת בטווח Google Cloudאו אם נקודות הקצה של המקור והיעד נמצאות מחוץ למרחב הכתובות של RFC 1918. הפרמטרים האלה נבחרים באופן אוטומטי על סמך כתובות ה-IP של המקור והיעד.

resource "google_network_management_connectivity_test" "default" {
  name = "conn-test-addr"
  source {
    ip_address   = google_compute_address.source_addr.address
    project_id   = google_compute_address.source_addr.project
    network      = google_compute_network.default.id
    network_type = "GCP_NETWORK"
  }

  destination {
    ip_address = google_compute_address.dest_addr.address
    project_id = google_compute_address.dest_addr.project
    network    = google_compute_network.default.id
    port       = "80"
  }

  protocol = "UDP"
}

resource "google_compute_network" "default" {
  name                    = "connectivity-vpc"
  auto_create_subnetworks = false
}

resource "google_compute_subnetwork" "default" {
  name          = "connectivity-vpc-subnet"
  ip_cidr_range = "10.0.0.0/8"
  region        = "us-central1"
  network       = google_compute_network.default.id
}

resource "google_compute_firewall" "default" {
  name    = "allow-incoming-all"
  network = google_compute_network.default.name

  allow {
    protocol = "all"
  }

  source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_address" "source_addr" {
  name         = "src-addr"
  subnetwork   = google_compute_subnetwork.default.id
  address_type = "INTERNAL"
  address      = "10.0.0.42"
  region       = "us-central1"
}

resource "google_compute_address" "dest_addr" {
  name         = "dest-addr"
  subnetwork   = google_compute_subnetwork.default.id
  address_type = "INTERNAL"
  address      = "10.0.0.43"
  region       = "us-central1"
}

resource "google_compute_instance" "source" {
  name         = "source-vm1"
  machine_type = "e2-medium"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = data.google_compute_image.default.id
    }
  }

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
    network_ip = "10.0.0.42"
    access_config {
    }
  }
}

resource "google_compute_instance" "destination" {
  name         = "dest-vm1"
  machine_type = "e2-medium"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = data.google_compute_image.default.id
    }
  }

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
    network_ip = "10.0.0.43"
    access_config {
    }
  }
}

data "google_compute_image" "default" {
  family  = "debian-11"
  project = "debian-cloud"
}

API

בדוגמה הזו נבדקת היכולת לבצע פינג מכתובת ה-IP של המקור לכתובת ה-IP של היעד.

משתמשים בשיטה projects.locations.global.connectivityTests.create.

  POST https://networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "network": "SOURCE_NETWORK",
      "networkType": "GCP_NETWORK",
    },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
    },
      "protocol": "PROTOCOL".
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

  POST https://networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?connectivityTestId=TEST_ID'
  {
    "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "networkType": "GCP_NETWORK"
    },
    "destination": {
      "instance": "DESTINATION_INSTANCE",
      "ipAddress": "DESTINATION_IP_ADDRESS"
    },
    "protocol": "PROTOCOL"
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

כשמציינים כתובת IP של מקור שהיא כתובת IP חיצונית מחוץ ל- Google Cloud, צריך להגדיר את הפרמטר networkType לערך INTERNET. מחליפים את הערכים בפקודה הבאה בערכים שמתאימים לרשת Google Cloud שלכם.

  POST https://networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "networkType": "INTERNET",
    },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
    },
    "protocol": "PROTOCOL",
  }'

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין שתי כתובות IP. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "network": "SOURCE_NETWORK",
      "networkType": "GCP_NETWORK"
  },
  "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
  },
  "protocol": "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדוגמה הבאה נוצרת בדיקה בין שתי כתובות IP:

test_input = {
    "source": {
        "ipAddress": "SOURCE_IP_ADDRESS",
        "network": "SOURCE_NETWORK",
        "networkType": "GCP_NETWORK"
    },
    "destination": {
        "ipAddress": "DESTINATION_IP_ADDRESS",
        "port": "DESTINATION_PORT",
    },
    "protocol": "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
  parent="projects/PROJECT_ID/locations/global",
  testId="TEST_ID",
  body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מכונת היעד.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

כשמציינים כתובת IP של מקור שהיא כתובת IP חיצונית מחוץ ל- Google Cloud, צריך להגדיר את הפרמטר networkType לערך INTERNET.

בדיקה ממכונה וירטואלית לשירות בניהול Google

בקטע הזה מוסבר איך לבצע בדיקה ממכונה וירטואלית ברשת ה-VPC שלכם לשירות שפועל ברשת VPC בבעלות Google. לדוגמה, אפשר לבצע את השלבים שבקטע הזה כדי לבדוק את הקישוריות למכונת Cloud SQL או למישור הבקרה של אשכול GKE. אפשר גם להריץ בדיקה באמצעות נקודת קצה של שירות שמנוהל על ידי Google כמקור, ונקודת קצה ברשת ה-VPC כיעד.

כברירת מחדל, הכלי לבדיקת קישוריות מנסה להריץ בדיקה באמצעות כתובת ה-IP הפרטית של נקודת הקצה של השירות שמנוהל על ידי Google. אם לנקודת הקצה אין כתובת IP פרטית, הכלי לבדיקת קישוריות משתמש בכתובת ה-IP הציבורית. בדיקות הקישוריות מנתחות אם החבילה יכולה להגיע לנקודת הקצה, כולל ניתוח ההגדרה ברשת ה-VPC שבבעלות Google. אם מזוהות בעיות בהגדרות בפרויקט, הניתוח נפסק לפני ניתוח ההגדרות של הרשת בבעלות Google.

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

המסוף

מדף בדיקות הקישוריות הראשי

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.

5. בקטע מקור, מבצעים את הפעולות הבאות:

   1. בתפריט Source endpoint, בוחרים באפשרות VM instance.
   2. בתפריט Source VM instance (מכונה וירטואלית של המקור), בוחרים את המכונה הווירטואלית הספציפית של המקור.

   3. בתפריט Source network interface (ממשק רשת של מקור), בוחרים את ממשק הרשת.

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

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

6. בקטע יעד, מבצעים את הפעולות הבאות:

   1. בתפריט Destination endpoint, בוחרים סוג של משאב שירות שמנוהל על ידי Google, כמו מישור הבקרה של אשכול GKE.
   2. בתפריט מישור הבקרה של אשכול GKE ליעד, בוחרים את האשכול שרוצים לבדוק את הקישוריות שלו למישור הבקרה של GKE.
   3. אופציונלי: בוחרים את נקודת הקצה של מישור הבקרה של אשכול GKE ביעד מהרשימה. ברירת המחדל היא נקודת הקצה מבוססת ה-IP של אשכול GKE.

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

מדף הפרטים של ממשק הרשת

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

   כניסה לדף VM instances

2. אם הוא לא נבחר כבר, בוחרים את הפרויקט שמכיל את המופע שרוצים להריץ עליו בדיקה.
3. לוחצים על המופע שבו רוצים להשתמש כדי להריץ בדיקה.
4. בקטע Network interfaces (ממשקי רשת), בוחרים את ממשק הרשת שרוצים להשתמש בו כדי להריץ בדיקה.
5. בקטע Network analysis (ניתוח רשת), לוחצים על Create Connectivity Test (יצירת בדיקת קישוריות).
6. בשדה שם הבדיקה, מזינים שם לבדיקה.
7. ברשימה Protocol, בוחרים פרוטוקול.
8. בשדה מקור, בוחרים באפשרות ממשק הרשת הנוכחי.
9. בקטע יעד, מבצעים את הפעולות הבאות:
   1. בתפריט Destination endpoint, בוחרים סוג של משאב שירות שמנוהל על ידי Google, כמו מישור הבקרה של אשכול GKE.
   2. בתפריט מישור הבקרה של אשכול GKE ליעד, בוחרים את האשכול שרוצים לבדוק את הקישוריות שלו למישור הבקרה של GKE.
   3. אופציונלי: בוחרים את נקודת הקצה של מישור הבקרה של אשכול GKE ביעד מהרשימה. ברירת המחדל היא נקודת הקצה מבוססת ה-IP של אשכול GKE.
10. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
    1. לוחצים על יצירה.
    2. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

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

gcloud network-management connectivity-tests create NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-ip-address=SOURCE_IP_ADDRESS \
      DESTINATION_RESOURCE_FLAG=DESTINATION_ENDPOINT \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.

• ‫DESTINATION_RESOURCE_FLAG: הדגל שמציין את סוג משאב השירות שמנוהל על ידי Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • --destination-gke-master-cluster
  • --destination-cloud-sql-instance
  • --destination-redis-instance
  • --destination-redis-cluster

  מידע נוסף זמין במקור המידע gcloud network-management connectivity-tests create.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת היעד, לדוגמה projects/myproject/locations/us-central1/clusters/cluster-1 עבור הדגל --destination-gke-master-cluster.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.

• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

 POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
   {
     "source": {
       "instance": "SOURCE_INSTANCE",
       "ipAddress": "SOURCE_IP_ADDRESS",
     },
     "destination": {
       "DESTINATION_RESOURCE_FIELD": "DESTINATION_ENDPOINT",
       "port": DESTINATION_PORT
     },
     "protocol": "PROTOCOL",
   }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.

• ‫DESTINATION_RESOURCE_FIELD: השדה שמציין את הסוג של משאב שירות בניהול Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • gkeMasterCluster
  • cloudSqlInstance
  • redisInstance
  • redisCluster

  מידע נוסף זמין במאמר הפניה לנקודות קצה.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת הקצה של היעד. לדוגמה, projects/myproject/locations/us-central1/clusters/cluster-1 בשדה gkeMasterCluster.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.

• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין מכונת VM לבין נקודת קצה של שירות שמנוהל על ידי Google. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "instance":
          "SOURCE_INSTANCE",
      "ipAddress":
          "SOURCE_IP_ADDRESS",
      "projectId":
          "SOURCE_INSTANCE_PROJECT_ID"
  },
  "destination": {
      "DESTINATION_RESOURCE_FIELD":
          "DESTINATION_ENDPOINT",
      "port":
          "DESTINATION_PORT"
  },
  "protocol":
      "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫SOURCE_INSTANCE_PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.

• ‫DESTINATION_RESOURCE_FIELD: השדה שמציין את הסוג של משאב שירות בניהול Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • gkeMasterCluster
  • cloudSqlInstance
  • redisInstance
  • redisCluster

  מידע נוסף זמין במאמר הפניה לנקודות קצה.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת הקצה של היעד. לדוגמה, projects/myproject/locations/us-central1/clusters/cluster-1 בשדה gkeMasterCluster.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.

• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.

• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה מ-VM לנקודות קצה של Private Service Connect

בקטע הזה מוסבר איך לבצע בדיקה ממכונה וירטואלית לנקודת קצה של Private Service Connect.

לדוגמה, אפשר לבצע את השלבים שבקטע הזה כדי לבדוק אם אפשר להעביר מנהת נתונים לשירות שפורסם ומשתמש ב-Private Service Connect. בדיקות הקישוריות מנתחות אם חבילת נתונים יכולה להגיע לנקודת הקצה, כולל ניתוח של נקודות קצה מקושרות, שירותים שפורסמו וחיבור ה-proxy. הניתוח מסתיים מוקדם אם החיבור לשירות שפורסם באמצעות Private Service Connect לא מתקבל.

אפשר לבדוק את הקישוריות אל:

• נקודות קצה של Google APIs

• נקודות קצה לשירותים שפורסמו

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.

5. בקטע מקור, מבצעים את הפעולות הבאות:

   1. בתפריט Source endpoint, בוחרים באפשרות VM instance.
   2. בתפריט Source VM instance (מכונה וירטואלית של המקור), בוחרים את המכונה הווירטואלית הספציפית של המקור.

   3. בתפריט Source network interface (ממשק רשת של מקור), בוחרים את ממשק הרשת.

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

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

6. בקטע יעד, מבצעים את הפעולות הבאות:

   1. בתפריט Destination endpoint (נקודת קצה של יעד), בוחרים באפשרות PSC endpoint (נקודת קצה של PSC).

   2. בתפריט Destination PSC endpoint (נקודת קצה של PSC ליעד), בוחרים את נקודת הקצה של PSC.

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

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של נקודת הקצה או של ה-Backend שרוצים לבדוק.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

בדוגמה הבאה של בדיקה, המערכת קובעת אם הגדרת הרשת הקיימת מאפשרת למכונה וירטואלית instance1 לשלוח פינג לכתובת ה-IP של נקודת הקצה של Private Service Connect.

משתמשים בשיטה projects.locations.global.connectivityTests.create.

 POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
   {
     "source": {
       "instance": "SOURCE_INSTANCE",
       "ipAddress": "SOURCE_IP_ADDRESS",
     },
    "destination": {
      "forwardingRule": "DESTINATION_FORWARDING_RULE",
      "port": "DESTINATION_PORT",
     },
     "protocol": "PROTOCOL",
   }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של נקודת הקצה או של ה-Backend שרוצים לבדוק.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין מכונת VM לבין נקודת קצה של Private Service Connect. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "instance":
          "SOURCE_INSTANCE",
      "ipAddress":
          "SOURCE_IP_ADDRESS",
      "projectId":
          "SOURCE_INSTANCE_PROJECT_ID"
  },
  "destination": {
      "forwardingRule": "DESTINATION_FORWARDING_RULE",
      "port": "DESTINATION_PORT",
  },
  "protocol":
      "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫SOURCE_INSTANCE_PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של נקודת הקצה או של ה-Backend שרוצים לבדוק.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה מגרסה של סביבה רגילה של App Engine ליעד

בקטע הזה מוסבר איך לבדוק את הקישוריות מגרסה של סביבת App Engine Standard למכונה וירטואלית, לכתובת IP או לשירות בניהול Google.

אפליקציה בסביבה רגילה של App Engine מורכבת ממשאב אפליקציה יחיד, שכולל שירות אחד או יותר. בכל שירות, פורסים גרסאות של השירות הזה. אפשר לבדוק את הנגישות מגרסה של שירות בסביבה רגילה של App Engine למכונה וירטואלית, לכתובת IP או לשירות שמנוהל על ידי Google.

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

בדיקת הקישוריות מגרסה של שירות בסביבה רגילה של App Engine למכונה וירטואלית

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. נותנים שם לבדיקה.
4. בוחרים פרוטוקול.
5. בתפריט Source endpoint, בוחרים באפשרות App Engine.
   1. בתפריט App Engine service, בוחרים את השירות הספציפי של הסביבה הסטנדרטית של App Engine שרוצים לבדוק את הקישוריות שלו. לדוגמה, בוחרים באפשרות helloworld-service.
      1. אם נקודת הקצה של המקור נמצאת בפרויקט אחר ולא בפרויקט הנוכחי, מסמנים את תיבת הסימון Endpoint is in a project other than "PROJECT_NAME".
      2. בוחרים פרויקט שבו קיים נקודת הקצה.
   2. בתפריט App Engine version, בוחרים גרסה של שירות הסביבה הסטנדרטית של App Engine שממנה רוצים לבדוק את הקישוריות.

6. בקטע יעד, בוחרים יעד של מכונת VM מהרשימה.

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

7. אופציונלי: בוחרים את כתובת ה-IP של היעד מהרשימה. ברירת המחדל היא כתובת ה-IP של מכונת היעד.

8. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

9. לוחצים על יצירה.

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

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-app-engine-version=APP_ENGINE_VERSION \
    --destination-instance=DESTINATION_INSTANCE \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫APP_ENGINE_VERSION: ה-URI של גרסת הסביבה הסטנדרטית של App Engine של המקור, לדוגמה, apps/myproject/services/service-name/versions/version-name.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

  POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "appEngineVersion": {
        "uri": "APP_ENGINE_VERSION",
        },
    },
    "destination": {
      "instance": "DESTINATION_INSTANCE",
      "ipAddress": "DESTINATION_IP_ADDRESS",
    },
    "protocol": "PROTOCOL",
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫APP_ENGINE_VERSION: ה-URI של גרסת הסביבה הסטנדרטית של App Engine של המקור, לדוגמה, apps/myproject/services/service-name/versions/version-name.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

בדיקת קישוריות מגרסה של שירות בסביבה רגילה של App Engine לכתובת IP

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. נותנים שם לבדיקה.
4. בוחרים פרוטוקול.
5. בתפריט Source endpoint, בוחרים באפשרות App Engine.
   1. בתפריט App Engine service, בוחרים את השירות הספציפי של הסביבה הסטנדרטית של App Engine שרוצים לבדוק את הקישוריות שלו. לדוגמה, בוחרים באפשרות helloworld-service.
      1. אם נקודת הקצה של המקור נמצאת בפרויקט אחר ולא בפרויקט הנוכחי, בוחרים באפשרות Endpoint is in a project other than "PROJECT_NAME" (נקודת הקצה נמצאת בפרויקט אחר ולא בפרויקט 'PROJECT_NAME').
      2. בוחרים פרויקט שבו קיים נקודת הקצה.
   2. בתפריט App Engine version, בוחרים גרסה של שירות הסביבה הסטנדרטית של App Engine שממנה רוצים לבדוק את הקישוריות.
6. בקטע יעד, בוחרים באפשרות כתובת IP ומזינים כתובת IP.
7. מזינים יעד.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-app-engine-version=APP_ENGINE_VERSION \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫APP_ENGINE_VERSION: ה-URI של גרסת הסביבה הסטנדרטית של App Engine של המקור, לדוגמה, apps/myproject/services/service-name/versions/version-name.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

  POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "appEngineVersion": {
        "uri": "APP_ENGINE_VERSION",
        },
    },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
    },
    "protocol": "PROTOCOL",
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫APP_ENGINE_VERSION: ה-URI של גרסת הסביבה הסטנדרטית של App Engine של המקור, לדוגמה, apps/myproject/services/service-name/versions/version-name.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

בדיקת קישוריות מגרסה של שירות בסביבה רגילה של App Engine לשירות בניהול Google

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. נותנים שם לבדיקה.
4. בוחרים פרוטוקול.
5. בתפריט Source endpoint, בוחרים באפשרות App Engine.
   1. בתפריט App Engine service, בוחרים את השירות הספציפי של הסביבה הסטנדרטית של App Engine שרוצים לבדוק את הקישוריות שלו. לדוגמה, בוחרים באפשרות helloworld-service.
      1. אם נקודת הקצה של המקור נמצאת בפרויקט אחר ולא בפרויקט הנוכחי, בוחרים באפשרות Endpoint is in a project other than "PROJECT_NAME" (נקודת הקצה נמצאת בפרויקט אחר ולא בפרויקט 'PROJECT_NAME').
      2. בוחרים פרויקט שבו קיים נקודת הקצה.
   2. בתפריט App Engine version, בוחרים גרסה של שירות הסביבה הסטנדרטית של App Engine שממנה רוצים לבדוק את הקישוריות.
6. בקטע יעד, מבצעים את הפעולות הבאות:
   1. בתפריט Destination endpoint, בוחרים סוג של משאב שירות שמנוהל על ידי Google, כמו מישור הבקרה של אשכול GKE.
   2. בתפריט מישור הבקרה של אשכול GKE ליעד, בוחרים את האשכול שרוצים לבדוק את הקישוריות שלו למישור הבקרה של GKE.
   3. אופציונלי: בוחרים את נקודת הקצה של מישור הבקרה של אשכול GKE ביעד מהרשימה. ברירת המחדל היא נקודת הקצה מבוססת ה-IP של אשכול GKE.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-app-engine-version=APP_ENGINE_VERSION \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
      DESTINATION_RESOURCE_FLAG=DESTINATION_ENDPOINT \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫APP_ENGINE_VERSION: ה-URI של גרסת הסביבה הסטנדרטית של App Engine של המקור, לדוגמה, apps/myproject/services/servicename/versions/version-number.
• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.

• ‫DESTINATION_RESOURCE_FLAG: הדגל שמציין את סוג משאב השירות שמנוהל על ידי Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • --destination-gke-master-cluster
  • --destination-cloud-sql-instance

  מידע נוסף זמין במקור המידע gcloud network-management connectivity-tests create.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת הקצה של היעד, לדוגמה projects/myproject/locations/us-central1/clusters/cluster-1 עבור הדגל --destination-gke-master-cluster.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.

• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

  POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "appEngineVersion": {
        "uri": "APP_ENGINE_VERSION",
        },
    },
    "destination": {
      "DESTINATION_RESOURCE_FIELD": "DESTINATION_ENDPOINT",
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": DESTINATION_PORT,
    },
    "protocol": "PROTOCOL",
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫APP_ENGINE_VERSION: ה-URI של גרסת הסביבה הסטנדרטית של App Engine של המקור, לדוגמה, apps/myproject/services/servicename/versions/version-number.

• ‫DESTINATION_RESOURCE_FIELD: השדה שמציין את הסוג של משאב שירות בניהול Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • gkeMasterCluster
  • cloudSqlInstance
  • redisInstance
  • redisCluster

  מידע נוסף זמין במאמר הפניה לנקודות קצה.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת הקצה של היעד. לדוגמה, projects/myproject/locations/us-central1/clusters/cluster-1 בשדה gkeMasterCluster.

• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.

• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

בדיקה מפונקציית Cloud Run ליעד

בקטע הזה מוסבר איך לבדוק את הקישוריות מפונקציית Cloud Run שנפרסה באזור מסוים Google Cloud למכונה וירטואלית, לכתובת IP או לשירות שמנוהל על ידי Google. לדוגמה, אפשר לבצע את השלבים שבקטע הזה כדי לבדוק את הקישוריות מפונקציית Cloud Run שפריסתה בוצעה ב-us-central1 כמקור לנקודת קצה ברשת ה-VPC כיעד.

כדי לראות ניתוח מפורט של ההגדרה, מוודאים שפונקציית Cloud Run פעילה.

אם אתם משתמשים במחבר Serverless VPC Access לפונקציית Cloud Run, חשוב לזכור שהגדרות היציאה של פונקציות Cloud Run שולטות בניתוב של בקשות HTTP יוצאות מפונקציית Cloud Run, ובסוגי התנועה שמנותבים דרך המחבר לרשת ה-VPC. מידע נוסף זמין במאמר בנושא הגדרות יציאה של פונקציות Cloud Run.

בדיקת הקישוריות מפונקציית Cloud Run למופע של מכונה וירטואלית

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint (נקודת קצה של המקור), בוחרים באפשרות Cloud Function 1st gen (פונקציית Cloud דור ראשון).
   2. בתפריט Cloud Function, בוחרים את הפונקציה הספציפית ב-Cloud Run שרוצים לבדוק את הקישוריות שלה. לדוגמה, בוחרים באפשרות function-1.
   3. בתפריט המיקום של Cloud Function, בוחרים את האזור שבו פרסתם את פונקציית Cloud Run. Google Cloud אפשר לפרוס פונקציות Cloud Run לכמה אזורים עם הגדרות שונות אבל עם אותו שם.

6. בקטע יעד, מבצעים את הפעולות הבאות:

   1. בתפריט Destination endpoint (נקודת קצה של היעד), בוחרים באפשרות VM instance (מופע של מכונה וירטואלית).
   2. בתפריט Destination VM instance, בוחרים מכונת VM.

   3. בתפריט Destination network interface, בוחרים את ממשק הרשת.

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

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

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-cloud-function=SOURCE_CLOUD_FUNCTION \
    --destination-instance=DESTINATION_INSTANCE \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_CLOUD_FUNCTION: ה-URI של פונקציית Cloud Run, לדוגמה: projects/myproject/locations/us-central1/functions/function-1.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
{
  "source": {
    "cloudFunction": {
      "uri": "SOURCE_CLOUD_FUNCTION",
      },
  },
  "destination": {
    "instance": "DESTINATION_INSTANCE",
    "ipAddress": "DESTINATION_IP_ADDRESS",
  },
  "protocol": "PROTOCOL",
}'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_CLOUD_FUNCTION: ה-URI של פונקציית Cloud Run, לדוגמה: projects/myproject/locations/us-central1/functions/function-1.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

בדיקת הקישוריות מפונקציית Cloud Run לכתובת IP

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint (נקודת קצה של המקור), בוחרים באפשרות Cloud Function 1st gen (פונקציית Cloud דור ראשון).
   2. בתפריט Cloud Function, בוחרים את הפונקציה הספציפית ב-Cloud Run שרוצים לבדוק את הקישוריות שלה. לדוגמה, בוחרים באפשרות function-1.
   3. בתפריט המיקום של Cloud Function, בוחרים את האזור שבו פרסתם את פונקציית Cloud Run. Google Cloud אפשר לפרוס פונקציות Cloud Run לכמה אזורים עם הגדרות שונות אבל עם אותו שם.
6. בקטע יעד, בוחרים באפשרות כתובת IP ומזינים כתובת IP.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. בהמשך הדף הזה מוסבר איך לצפות בתוצאות הבדיקה.

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-cloud-function=SOURCE_CLOUD_FUNCTION \
    --destination-ip-address==DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_CLOUD_FUNCTION: ה-URI של פונקציית Cloud Run, לדוגמה projects/myproject/locations/us-central1/functions/function-1.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
{
  "source": {
    "cloudFunction": {
      "uri": "SOURCE_CLOUD_FUNCTION",
    },
  },
  "destination": {
    "ipAddress": "DESTINATION_IP_ADDRESS",
  },
  "protocol": "PROTOCOL",
}'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_CLOUD_FUNCTION: ה-URI של פונקציית Cloud Run, לדוגמה: projects/myproject/locations/us-central1/functions/function-1.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

בדיקת הקישוריות מפונקציית Cloud Run לשירות בניהול Google

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint (נקודת קצה של המקור), בוחרים באפשרות Cloud Function 1st gen (פונקציית Cloud דור ראשון).
   2. בתפריט Cloud Function, בוחרים את הפונקציה הספציפית ב-Cloud Run שרוצים לבדוק את הקישוריות שלה. לדוגמה, בוחרים באפשרות function-1.
   3. בתפריט Cloud Function location (מיקום הפונקציה ב-Cloud), בוחרים את האזור Google Cloud שבו פרסתם את הפונקציה ב-Cloud Run. אפשר לפרוס פונקציות Cloud Run לכמה אזורים עם הגדרות שונות אבל עם אותו שם.
6. בקטע יעד, מבצעים את הפעולות הבאות:
   1. בתפריט יעד נקודת קצה, בוחרים סוג של משאב שירות שמנוהל על ידי Google, כמו מופע Cloud SQL.
   2. בתפריט יעד מופע Cloud SQL, בוחרים את מופע Cloud SQL שממנו רוצים לבדוק את הקישוריות.
   3. אופציונלי: בוחרים את כתובת ה-IP של מכונת היעד של Cloud SQL מהרשימה. ברירת המחדל היא כתובת ה-IP של פונקציית Cloud Run של המקור.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. בהמשך הדף הזה מוסבר איך לצפות בתוצאות הבדיקה.

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-cloud-function=SOURCE_CLOUD_FUNCTION \
      DESTINATION_RESOURCE_FLAG=DESTINATION_ENDPOINT \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_CLOUD_FUNCTION: ה-URI של פונקציית Cloud Run, לדוגמה, projects/myproject/locations/us-central1/functions/function-1.

• ‫DESTINATION_RESOURCE_FLAG: הדגל שמציין את סוג משאב השירות שמנוהל על ידי Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • --destination-gke-master-cluster
  • --destination-cloud-sql-instance
  • --destination-redis-instance
  • --destination-redis-cluster

  מידע נוסף זמין במקור המידע gcloud network-management connectivity-tests create.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת היעד, לדוגמה projects/myproject/locations/us-central1/clusters/cluster-1 עבור הדגל --destination-gke-master-cluster.

• DESTINATION_IP_ADDRESS: כתובת ה-IP הפנימית או החיצונית של היעד שאתם בודקים.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.

• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

בדיקה מגרסת Cloud Run ליעד

בקטע הזה מוסבר איך לבדוק את הקישוריות מגרסת Cloud Run למכונה וירטואלית, לכתובת IP או לשירות שמנוהל על ידי Google.

אפשר לפרוס כמה שירותי Cloud Run בפרויקט אחד. לכל שירות Cloud Run יש נקודת קצה של HTTPS בתת-דומיין ייחודי של דומיין *.run.app. כל פריסה של שירות Cloud Run יוצרת גרסה חדשה שלא ניתן לשנות. אפשר לבדוק את הנגישות מגרסה למכונה וירטואלית, לכתובת IP או לשירות בניהול Google.

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

יכול להיות שתוצאות בדיקת הקישוריות יהיו שונות בכל גרסה. לדוגמה, לשירות Cloud Run בשם cloud_run_test יש גרסה first-revision שמוגדרת לשימוש במחבר Serverless VPC Access, גרסה second-revision שמוגדרת לשימוש ב-Direct VPC egress וגרסה נוספת third-revision ללא גישה ל-VPC. יכול להיות שכל אחת מהגרסאות האלה תחזיר סטטוס זמינות שונה. לדוגמה, יכול להיות שאפשר להגיע לשתי הגרסאות הראשונות אבל לא לגרסה השלישית.

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

בדיקת קישוריות מגרסה של שירות Cloud Run למכונה וירטואלית

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. נותנים שם לבדיקה.
4. בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint (נקודת קצה של המקור), בוחרים באפשרות Cloud Run.
   2. בתפריט Cloud Run service (שירות Cloud Run), בוחרים את שירות Cloud Run הספציפי שרוצים לבדוק את הקישוריות שלו. לדוגמה, בוחרים באפשרות helloworld-run.
      1. אם נקודת הקצה של המקור נמצאת בפרויקט אחר ולא בפרויקט הנוכחי, בוחרים באפשרות Endpoint is in a project other than "PROJECT_NAME" (נקודת הקצה נמצאת בפרויקט אחר ולא בפרויקט 'PROJECT_NAME').
      2. בוחרים פרויקט שבו קיים נקודת הקצה.
   3. בתפריט Cloud Run revision בוחרים גרסת Cloud Run שרוצים לבדוק.

6. בקטע יעד, מבצעים את הפעולות הבאות:

   1. בתפריט Destination endpoint (נקודת קצה של היעד), בוחרים באפשרות VM instance (מופע של מכונה וירטואלית).
   2. בתפריט Destination VM instance, בוחרים את מכונת ה-VM הספציפית של היעד.

   3. בתפריט Destination network interface (ממשק רשת יעד), בוחרים את ממשק הרשת.

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

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

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-cloud-run-revision=CLOUD_RUN_REVISION \
    --destination-instance=DESTINATION_INSTANCE \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫CLOUD_RUN_REVISION: ה-URI של הגרסה של Cloud Run במקור, לדוגמה: projects/myproject/locations/us-central1/revisions/cloudrun-revision.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
{
  "source": {
    "cloudRunRevision": {
      "uri": "CLOUD_RUN_REVISION",
      },
  },
    "destination": {
      "instance": "DESTINATION_INSTANCE",
      "ipAddress": "DESTINATION_IP_ADDRESS"
      },
    "protocol": "PROTOCOL",
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫CLOUD_RUN_REVISION: ה-URI של הגרסה של Cloud Run במקור, לדוגמה: projects/myproject/locations/us-central1/revisions/cloudrun-revision.
• ‫DESTINATION_INSTANCE: ה-URI של מכונת היעד, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-2.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מופע ה-VM של היעד שאתם בודקים. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של היעד.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

בדיקת הקישוריות מגרסה של שירות Cloud Run לכתובת IP

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. נותנים שם לבדיקה.
4. בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint (נקודת קצה של המקור), בוחרים באפשרות Cloud Run.
   2. בתפריט Cloud Run service (שירות Cloud Run), בוחרים את שירות Cloud Run הספציפי שרוצים לבדוק את הקישוריות שלו. לדוגמה, בוחרים באפשרות helloworld-run.
      1. אם נקודת הקצה של המקור נמצאת בפרויקט אחר ולא בפרויקט הנוכחי, בוחרים באפשרות Endpoint is in a project other than "PROJECT_NAME" (נקודת הקצה נמצאת בפרויקט אחר ולא בפרויקט 'PROJECT_NAME').
      2. בוחרים פרויקט שבו קיים נקודת הקצה.
   3. בתפריט Cloud Run revision בוחרים גרסת Cloud Run שרוצים לבדוק.
6. בקטע יעד, בוחרים באפשרות כתובת IP ומזינים כתובת IP.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-cloud-run-revision=CLOUD_RUN_REVISION \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫CLOUD_RUN_REVISION: ה-URI של הגרסה של Cloud Run במקור, לדוגמה: projects/myproject/locations/us-central1/revisions/cloudrun-revision.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
{
  "source": {
    "cloudRunRevision": {
      "uri": "CLOUD_RUN_REVISION",
      },
  },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      },
    "protocol": "PROTOCOL",
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫CLOUD_RUN_REVISION: ה-URI של הגרסה של Cloud Run במקור, לדוגמה: projects/myproject/locations/us-central1/revisions/cloudrun-revision.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

בדיקת הקישוריות מגרסה של שירות Cloud Run לשירות שמנוהל על ידי Google

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. נותנים שם לבדיקה.
4. בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט Source endpoint (נקודת קצה של המקור), בוחרים באפשרות Cloud Run.
   2. בתפריט Cloud Run service (שירות Cloud Run), בוחרים את שירות Cloud Run הספציפי שרוצים לבדוק את הקישוריות שלו. לדוגמה, בוחרים באפשרות helloworld-run.
      1. אם נקודת הקצה של המקור נמצאת בפרויקט אחר ולא בפרויקט הנוכחי, בוחרים באפשרות Endpoint is in a project other than "PROJECT_NAME" (נקודת הקצה נמצאת בפרויקט אחר ולא בפרויקט 'PROJECT_NAME').
      2. בוחרים פרויקט שבו קיים נקודת הקצה.
   3. בתפריט Cloud Run revision בוחרים גרסת Cloud Run שרוצים לבדוק.
6. בקטע יעד, מבצעים את הפעולות הבאות:
   1. בתפריט Destination endpoint, בוחרים סוג של משאב שירות שמנוהל על ידי Google, כמו מישור הבקרה של אשכול GKE.
   2. בתפריט מישור הבקרה של אשכול GKE ליעד, בוחרים את האשכול שרוצים לבדוק את הקישוריות שלו למישור הבקרה של GKE.
   3. אופציונלי: בוחרים את נקודת הקצה של מישור הבקרה של אשכול GKE ביעד מהרשימה. ברירת המחדל היא נקודת הקצה מבוססת ה-IP של אשכול GKE.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-cloud-run-revision=CLOUD_RUN_REVISION \
      DESTINATION_RESOURCE_FLAG=DESTINATION_ENDPOINT \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫CLOUD_RUN_REVISION: ה-URI של הגרסה של Cloud Run במקור, לדוגמה: projects/myproject/locations/us-central1/revisions/cloudrun-revision.
• ‫PROJECT_NAME: שם הפרויקט שבו נמצאת נקודת הקצה, לדוגמה, myproject.

• ‫DESTINATION_RESOURCE_FLAG: הדגל שמציין את סוג משאב השירות שמנוהל על ידי Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • --destination-gke-master-cluster
  • --destination-cloud-sql-instance
  • --destination-redis-instance
  • --destination-redis-cluster

  מידע נוסף זמין במקור המידע gcloud network-management connectivity-tests create.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת היעד, לדוגמה projects/myproject/locations/us-central1/clusters/cluster-1 עבור הדגל --destination-gke-master-cluster.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.

• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
{
  "source": {
    "cloudRunRevision": {
      "uri": "CLOUD_RUN_REVISION",
      },
  },
    "destination": {
      "DESTINATION_RESOURCE_FIELD": "DESTINATION_ENDPOINT",
      "port": DESTINATION_PORT,
    },
    "protocol": "PROTOCOL",
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של פונקציית Cloud Run של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫CLOUD_RUN_REVISION: ה-URI של הגרסה של Cloud Run במקור, לדוגמה: projects/myproject/locations/us-central1/revisions/cloudrun-revision.

• ‫DESTINATION_RESOURCE_FIELD: השדה שמציין את הסוג של משאב שירות בניהול Google.

  אפשרויות זמינות מפורטות במאמרים הבאים:

  • gkeMasterCluster
  • cloudSqlInstance
  • redisInstance
  • redisCluster

  מידע נוסף זמין במאמר הפניה לנקודות קצה.

• ‫DESTINATION_ENDPOINT: ה-URI של נקודת הקצה של היעד. לדוגמה, projects/myproject/locations/us-central1/clusters/cluster-1 בשדה gkeMasterCluster.

• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP. ברירת המחדל היא יציאה 80.

• ‫PROTOCOL: פרוטוקולי הרשת שנתמכים על ידי מחברי חיבור לרשת (VPC) מאפליקציית serverless –‏ TCP או UDP.

בדיקה מרשת VPC לרשת שאינהGoogle Cloud

כדי לבצע בדיקה מרשת VPC לרשת שאינה רשתGoogle Cloud , צריך לבצע את השלבים הבאים.

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, בוחרים באפשרות כתובת IP, מזינים כתובת IP ואז בוחרים את סוג כתובת ה-IP.
6. בשדה יעד, בוחרים באפשרות כתובת IP ומזינים כתובת IP חיצונית.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

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

gcloud network-management connectivity-tests create NAME \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --source-network=SOURCE_NETWORK \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

בדוגמה הזו נבדקת היכולת לבצע פינג מכתובת ה-IP של המקור לכתובת ה-IP של היעד.

משתמשים בשיטה projects.locations.global.connectivityTests.create.

  POST https://networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "network": "SOURCE_NETWORK"
    },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
    },
      "protocol": "PROTOCOL".
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין שתי כתובות IP. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "projectId": "SOURCE_IP_PROJECT_ID"
  },
  "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
  },
  "protocol": "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_IP_PROJECT_ID: מזהה הפרויקט של כתובת ה-IP של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדוגמה הבאה נוצרת בדיקה בין שתי כתובות IP:

test_input = {
    "source": {
        "ipAddress": "SOURCE_IP_ADDRESS",
        "networkType": "GCP_NETWORK"
    },
    "destination": {
        "ipAddress": "DESTINATION_IP_ADDRESS",
        "port": "DESTINATION_PORT",
    },
    "protocol": "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
  parent="projects/PROJECT_ID/locations/global",
  testId="TEST_ID",
  body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של היעד
• ‫DESTINATION_PORT: מספר יציאת ה-TCP או ה-UDP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה מ-VPC spoke ל-VPC spoke אחר שמחובר לאותו NCC hub

כדי לבדוק מ-VPC spoke ב-NCC hub ל-VPC spoke אחר שמחובר לאותו hub, פועלים לפי השלבים הבאים.

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, בוחרים באפשרות כתובת IP, ואז מזינים את כתובת ה-IP מרשת ה-VPC של ה-spoke.
6. בשדה Destination, בוחרים באפשרות IP address, ואז מזינים את כתובת ה-IP ברשת VPC מסוג spoke אחרת שאתם בודקים.
7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.
8. לוחצים על יצירה.
9. אחרי שהבדיקה מסתיימת, נטען הדף הראשי בדיקות קישוריות ומוצגת רשימה שכוללת את הבדיקה הזו ובדיקות אחרות. ממשיכים אל הצגת תוצאות הבדיקה.

gcloud

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

gcloud network-management connectivity-tests create NAME \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --source-network=SOURCE_NETWORK \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של היעד ברשת VPC מסוג spoke אחרת שאתם בודקים.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

בדוגמה הזו נבדקת היכולת לבצע פינג מכתובת ה-IP של המקור לכתובת ה-IP של היעד.

משתמשים בשיטה projects.locations.global.connectivityTests.create.

  POST https://networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "network": "SOURCE_NETWORK"
    },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
    },
      "protocol": "PROTOCOL".
  }'

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

• ‫PROJECT_ID: מזהה הפרויקט של המכונה הווירטואלית של המקור
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_NETWORK: ה-URI של רשת ה-VPC שבה נמצאת כתובת ה-IP של המקור – לדוגמה, projects/myproject/global/networks/default.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של היעד ברשת VPC מסוג spoke אחרת שאתם בודקים.
• ‫DESTINATION_PORT: מספר יציאת ה-TCP או ה-UDP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין שתי כתובות IP. מידע נוסף זמין במאמר על השיטה create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "projectId": "SOURCE_IP_PROJECT_ID"
  },
  "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
  },
  "protocol": "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫SOURCE_IP_PROJECT_ID: מזהה הפרויקט של כתובת ה-IP של המקור
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של היעד ברשת VPC מסוג spoke אחרת שאתם בודקים.
• ‫DESTINATION_PORT: מספר יציאת ה-TCP או ה-UDP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדוגמה הבאה נוצרת בדיקה בין שתי כתובות IP:

test_input = {
    "source": {
        "ipAddress": "SOURCE_IP_ADDRESS",
        "networkType": "GCP_NETWORK"
    },
    "destination": {
        "ipAddress": "DESTINATION_IP_ADDRESS",
        "port": "DESTINATION_PORT",
    },
    "protocol": "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
  parent="projects/PROJECT_ID/locations/global",
  testId="TEST_ID",
  body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP של מכונת היעד.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה ממכונה וירטואלית לרשת שאינהGoogle Cloud

בבדיקה הזו מנותחת הקישוריות מהמכונה הווירטואלית של המקור אל מיקום קצה של רשת Google.

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

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.

5. בקטע מקור, מבצעים את הפעולות הבאות:

   1. בתפריט Source endpoint, בוחרים באפשרות VM instance.
   2. בתפריט Source VM instance (מכונה וירטואלית של המקור), בוחרים את המכונה הווירטואלית הספציפית של המקור.

   3. בתפריט Source network interface (ממשק רשת של מקור), בוחרים את ממשק הרשת.

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

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

6. בקטע יעד, מבצעים את הפעולות הבאות:

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

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

gcloud

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

gcloud network-management connectivity-tests create NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \
    --protocol=PROTOCOL

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מכונת ה-VM שממנה אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של מכונת ה-VM של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

API

בבדיקה לדוגמה הבאה נקבע אם הגדרת הרשת הקיימת מאפשרת למכונה וירטואלית instance1לשלוח פינג לכתובת ה-IP של היעד.

משתמשים בשיטה projects.locations.global.connectivityTests.create.

 POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
   {
     "source": {
       "instance": "SOURCE_INSTANCE",
       "ipAddress": "SOURCE_IP_ADDRESS",
     },
    "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
     },
     "protocol": "PROTOCOL",
   }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

קוד הדוגמה הבא יוצר בדיקה בין מופע של מכונה וירטואלית לבין כתובת IP חיצונית. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "instance":
          "SOURCE_INSTANCE",
      "ipAddress":
          "SOURCE_IP_ADDRESS",
      "projectId":
          "SOURCE_INSTANCE_PROJECT_ID"
  },
  "destination": {
      "ipAddress": "DESTINATION_IP_ADDRESS",
      "port": "DESTINATION_PORT",
  },
  "protocol":
      "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫SOURCE_INSTANCE_PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה מתוך מכונה וירטואלית או כתובת IP למאזן עומסים

בקטע הזה מוסבר איך לבדוק את הקישוריות ממכונה וירטואלית או מכתובת IP אלGoogle Cloud מאזן עומסים.

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

אפשר לבדוק את הקישוריות אל:

• מאזן עומסים חיצוני של אפליקציות (ALB)
• מאזן עומסים פנימי של אפליקציות (ALB)
• מאזן עומסי רשת חיצוני להעברת סיגנל ללא שינוי
• מאזן עומסי רשת פנימי להעברת סיגנל ללא שינוי
• מאזן עומסי רשת חיצוני לשרת proxy

בדיקה מ-VM למאזן עומסים

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

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.

5. בקטע מקור, מבצעים את הפעולות הבאות:

   1. בתפריט Source endpoint, בוחרים באפשרות VM instance.
   2. בתפריט Source VM instance (מכונה וירטואלית של המקור), בוחרים את המכונה הווירטואלית הספציפית של המקור.

   3. בתפריט Source network interface (ממשק רשת של מקור), בוחרים את ממשק הרשת.

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

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

6. בקטע יעד, מבצעים את הפעולות הבאות:

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

   2. בתפריט מאזן העומסים של היעד, בוחרים את מאזן העומסים.

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

   3. בוחרים באפשרות כלל להעברה ליעד.

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

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

gcloud

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

gcloud network-management connectivity-tests create NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --protocol=PROTOCOL \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע המכונה הווירטואלית של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של מופע המכונה הווירטואלית של המקור.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.

API

משתמשים בשיטה projects.locations.global.connectivityTests.create.

 POST https: //networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
   {
     "source": {
       "instance": "SOURCE_INSTANCE",
       "ipAddress": "SOURCE_IP_ADDRESS",
     },
    "destination": {
      "forwardingRule": "DESTINATION_FORWARDING_RULE",
      "port": "DESTINATION_PORT",
     },
     "protocol": "PROTOCOL",
   }'

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.
• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫DESTINATION_FORWARDING_RULE: כלל ההעברה של היעד שמייצג את נקודת הקצה.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין מופע של מכונה וירטואלית לבין נקודת קצה של איזון עומסים. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

test_input = {
  "source": {
      "instance":
          "SOURCE_INSTANCE",
      "ipAddress":
          "SOURCE_IP_ADDRESS",
      "projectId":
          "SOURCE_INSTANCE_PROJECT_ID"
  },
  "destination": {
      "forwardingRule": "DESTINATION_FORWARDING_RULE",
      "port": "DESTINATION_PORT",
  },
  "protocol":
      "PROTOCOL",
}

request = api.projects().locations().global_().connectivityTests().create(
    parent="projects/PROJECT_ID/locations/global",
    testId="TEST_ID",
    body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_INSTANCE: ה-URI של מכונת ה-VM של המקור, לדוגמה projects/myproject/zones/us-east1-b/instances/instance-1.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫SOURCE_INSTANCE_PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫DESTINATION_FORWARDING_RULE: כלל ההעברה של היעד שמייצג את נקודת הקצה.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה מכתובת IP למאזן עומסים

המסוף

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. לוחצים על יצירת בדיקת קישוריות.
3. בשדה שם הבדיקה, מזינים שם לבדיקה.
4. ברשימה Protocol, בוחרים פרוטוקול.
5. בקטע מקור, מבצעים את הפעולות הבאות:
   1. בתפריט נקודת קצה של המקור, בוחרים באפשרות כתובת IP.
   2. בשדה כתובת IP של המקור, מזינים את כתובת ה-IP של המקור ואז בוחרים את סוג כתובת ה-IP.

6. בקטע יעד, מבצעים את הפעולות הבאות:

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

   2. בתפריט Destination Load Balancer, בוחרים את נקודת הקצה של איזון העומסים.

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

   3. בוחרים באפשרות כלל להעברה ליעד.

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

7. בשדה יעד הניוד, מזינים את יעד הניוד של היעד שצוין.

8. לוחצים על יצירה.

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

gcloud

משתמשים בפקודה gcloud network-management connectivity-tests create. מחליפים את ערכי הדוגמה בערכים מרשת ה-VPC שלכם.

gcloud network-management connectivity-tests create NAME \
    --source-project=SOURCE_PROJECT \
    --source-ip-address=SOURCE_IP_ADDRESS \
    --protocol=PROTOCOL \
    --destination-ip-address=DESTINATION_IP_ADDRESS \
    --destination-port=DESTINATION_PORT \

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

• ‫NAME: השם של בדיקת הקישוריות.
• ‫SOURCE_PROJECT: מזהה הפרויקט של נקודת הקצה של המקור.
• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של מופע מכונת ה-VM של המקור שממנו אתם מבצעים את הבדיקה. כתובת ה-IP צריכה להיות אחת מכתובות ה-IP של המכונה הווירטואלית של המקור.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫DESTINATION_IP_ADDRESS: כתובת ה-IP החיצונית של היעד שאתם בודקים.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.

API

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

משתמשים בשיטה projects.locations.global.connectivityTests.create.

כשמציינים כתובת IP של מקור שהיא כתובת IP חיצונית מחוץ ל- Google Cloud, צריך להגדיר את הפרמטר networkType לערך INTERNET. מחליפים את הערכים בפקודה הבאה בערכים שמתאימים לרשת Google Cloud שלכם.

  POST https://networkmanagement.googleapis.com/v1/projects/PROJECT_ID/locations/global/connectivityTests?testId=TEST_ID'
  {
    "source": {
      "ipAddress": "SOURCE_IP_ADDRESS",
      "networkType": "INTERNET",
    },
    "destination": {
      "forwardingRule": "DESTINATION_FORWARDING_RULE",
      "port": "DESTINATION_PORT",
    },
    "protocol": "PROTOCOL",
  }'

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫DESTINATION_FORWARDING_RULE: כלל ההעברה של היעד שמייצג את נקודת הקצה.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.

Python

בדוגמת הקוד הבאה נוצרת בדיקה בין כתובת IP לבין נקודת קצה של איזון עומסים. מידע נוסף זמין במאמר create בספריית הלקוח של Google API ל-Python.

כשמציינים כתובת IP של מקור שהיא כתובת IP חיצונית מחוץ ל- Google Cloud, צריך להגדיר את הפרמטר networkType לערך INTERNET.

test_input = {
    "source": {
        "ipAddress": "SOURCE_IP_ADDRESS",
        "networkType": "INTERNET"
    },
    "destination": {
        "forwardingRule": "DESTINATION_FORWARDING_RULE",
        "port": "DESTINATION_PORT",
        "projectId": "DESTINATION_IP_PROJECT_ID"
    },
    "protocol": "PROTOCOL",
}

  request = api.projects().locations().global_().connectivityTests().create(
  parent="projects/PROJECT_ID/locations/global",
  testId="TEST_ID",
  body=test_input)

print(json.dumps(request.execute(), indent=4))

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

• ‫SOURCE_IP_ADDRESS: כתובת ה-IP של המקור שממנו אתם מבצעים את הבדיקה.
• ‫DESTINATION_FORWARDING_RULE: כלל ההעברה של היעד שמייצג את נקודת הקצה.
• ‫DESTINATION_PORT: יציאת פרוטוקול ה-IP של היעד. האפשרות הזו תקפה רק לפרוטוקולי TCP או UDP.
• ‫DESTINATION_IP_PROJECT_ID: מזהה הפרויקט של כתובת ה-IP של היעד.
• ‫PROTOCOL: פרוטוקול נתמך לבדיקות קישוריות. פרוטוקול ברירת המחדל הוא TCP.
• ‫PROJECT_ID: מזהה הפרויקט שבו אתם יוצרים את הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

בדיקה מרשת שאינה רשתGoogle Cloud לרשת VPC

ההליך הזה זהה לבדיקה בין כתובות IP פרטיות ברשת VPC.

אם אתם משתמשים ב-Google Cloud CLI או ב-Network Management API, צריך להגדיר את סוג רשת המקור ל-NON_GCP_NETWORK ואת רשת המקור לרשת של מנהרת Cloud VPN, של צירוף ל-VLAN של Cloud Interconnect או של מופע נתב וירטואלי.

בדיקה מרשת לאGoogle Cloud לרשת לאGoogle Cloud

ההליך הזה זהה לבדיקה בין כתובות IP פרטיות ברשת VPC.

אם אתם משתמשים ב-Google Cloud CLI או ב-Network Management API, צריך להגדיר את סוג רשת המקור ל-NON_GCP_NETWORK ואת רשת המקור לרשת של מנהרת Cloud VPN, של צירוף ל-VLAN של Cloud Interconnect או של מופע נתב וירטואלי.

צפייה בתוצאות הבדיקה

בקטע הזה מוסבר איך לצפות בתוצאות של בדיקת הקישוריות.

המסוף

אפשר לראות את הבדיקה מכמה דפים שונים.

מדף בדיקות הקישוריות הראשי

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. בעמודה פרטי התוצאה, בוחרים בדיקה ולוחצים על הצגה.

3. מוצגת חלונית המידע של הבדיקה. אפשר לראות את התוצאה הכוללת ואת כרטיסי התוצאות של כל Google Cloud משאב בנתיב הבדיקה. אפשר ללחוץ על קישור כדי לעבור לדף הפרטים של חלק מהמשאבים, כמו מכונות וירטואליות או מסלולים. Google Cloudאם הבדיקה מכילה כמה עקבות, אפשר לבחור עקבה מהרשימה Trace result.

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

4. כדי להרחיב או לסגור כרטיס תוצאות, לוחצים על החץ בצד שמאל של הכרטיס.

5. כדי להבין את תוצאות הבדיקה, אפשר לעיין במאמר בנושא מצבי ניתוח ההגדרות.

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

מדף הפרטים של בדיקת הקישוריות

לחלופין, בדף הראשי של Google Cloud המסוף, לוחצים על שם הבדיקה ורואים את התוצאות שלה בדף Connectivity Test details (פרטי בדיקת הקישוריות).

מדף הפרטים של ממשק הרשת

אפשר גם לראות את התוצאות בדף Network interface details של ממשק רשת של מכונה וירטואלית ב-Compute Engine. בדף הזה מפורטות רק בדיקות שמשתמשות בממשק הרשת הנוכחי כמקור או כיעד.

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

gcloud

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

gcloud network-management connectivity-tests describe NAME

מחליפים את NAME בשם של בדיקת הקישוריות.

API

משתמשים בשיטה projects.locations.global.connectivityTests.get כדי לראות את תוצאות הבדיקה.

  GET https://networkmanagement.googleapis.com/v1/{name=projects/PROJECT_ID/locations/global/connectivityTests/TEST_ID}

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט בדיקות הקישוריות (test) שאתם מריצים.

Python

בדוגמת הקוד הבאה מוצגות תוצאות של בדיקה. מידע נוסף זמין במאמר בנושא get בספריית הלקוח של Google API ל-Python.

project_id = "PROJECT_ID"
test_id= "TEST_ID"
request = api.projects().locations().global_().connectivityTests().get(
      name='projects/%s/locations/global/connectivityTests/%s' %
      (project_id, test_id))

print(json.dumps(request.execute(), indent=4))

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

• ‫PROJECT_ID: מזהה הפרויקט שבו נוצר הבדיקה.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

הפעלה מחדש של בדיקה אחת או יותר

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

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

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

המסוף

מדף בדיקות הקישוריות הראשי

1. במסוף Google Cloud , נכנסים לדף בדיקות קישוריות.

   מעבר אל בדיקות קישוריות

2. בוחרים בדיקה אחת או יותר מתוך רשימת בדיקות הקישוריות הזמינות.
3. לוחצים על הפעלה מחדש.

מדף הפרטים של בדיקות הקישוריות

1. בדף הראשי בדיקות קישוריות שמופיע למעלה, לוחצים על שם הבדיקה.
2. בחלק העליון של הדף פרטי בדיקת הקישוריות, לוחצים על הפעלה מחדש.

מדף הפרטים של ממשק הרשת

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

   כניסה לדף VM instances

2. אם הוא לא נבחר כבר, בוחרים את הפרויקט שמכיל את המופע שרוצים להפעיל מחדש את הבדיקה שלו.
3. לוחצים על המופע שבו רוצים להשתמש כדי להריץ מחדש בדיקה.
4. בקטע ממשקי רשת, בוחרים את ממשק הרשת שרוצים להשתמש בו כדי להריץ מחדש בדיקה.
5. בקטע ניתוח רשת, לוחצים על בדיקות קישוריות.
6. בוחרים בדיקה אחת או יותר מתוך רשימת בדיקות הקישוריות הזמינות.
7. לוחצים על הפעלה מחדש.

gcloud

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

gcloud network-management connectivity-tests rerun NAME

מחליפים את NAME בשם של בדיקת הקישוריות.

API

כש-Network Management API יוצר משאב connectivityTests, הוא שומר את משאב הבדיקה הזה עד שמוחקים אותו. לכן, אפשר להריץ מחדש בדיקות.

אם אתם לא רוצים ליצור בדיקות קבועות, אתם יכולים להשתמש ב-API כדי ליצור בדיקה ולמחוק אותה אחרי הצגת תוצאת הבדיקה.

משתמשים ב-‎projects.locations.global.connectivityTests.rerun method כדי להריץ מחדש בדיקה.

  POST https://networkmanagement.googleapis.com/v1/{name=projects/*/locations/global/connectivityTests/*}:rerun
    {
      "name": {projects/PROJECT_ID/connectivityTests/{TEST_ID}}
    }

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

• ‫PROJECT_ID: מזהה הפרויקט של מכונת ה-VM של המקור.
• ‫TEST_ID: המזהה של אובייקט (בדיקה) בדיקות קישוריות שאתם מריצים.

Python

קוד הדוגמה הבא מריץ מחדש בדיקה. מידע נוסף זמין במאמר rerun בספריית הלקוח של Google API ל-Python.

project_id = "PROJECT_ID"
test_id = "TEST_ID"
request = api.projects().locations().global_().connectivityTests().rerun(name='projects/%s/locations/global/connectivityTests/%s' % (project_id, test_id))

print(json.dumps(request.execute(), indent=4))

מחליפים את הערכים הבאים:

• ‫PROJECT_ID: מזהה הפרויקט שבו נוצר הבדיקה
• ‫TEST_ID: המזהה של אובייקט בדיקות הקישוריות (הבדיקה) שאתם מריצים

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

• מצבי ניתוח ההגדרה
• פתרון בעיות בבדיקות קישוריות