שימוש ב-Private Service Connect כדי לגשת לצינורות עיבוד נתונים לאימון ממיקום מקומי

‫Gemini Enterprise Agent Platform Pipelines הוא שירות מנוהל שעוזר לכם ליצור, לפרוס ולנהל תהליכי עבודה מקצה לקצה של למידת מכונה (ML) בפלטפורמת Google Cloud . הוא מספק סביבה ללא שרת (serverless) להרצת צינורות עיבוד הנתונים, כך שלא צריך לדאוג לניהול התשתית.

במדריך הזה תשתמשו ב-Agent Platform Pipelines כדי להריץ משימת אימון בהתאמה אישית ולפרוס את המודל שאומן ב-Gemini Enterprise Agent Platform, בסביבת רשת היברידית.

התהליך כולו נמשך שעתיים עד שלוש שעות, כולל כ-50 דקות להרצת צינור עיבוד הנתונים.

המדריך הזה מיועד למנהלי רשתות בארגונים, למדעני נתונים ולחוקרים שמכירים את Gemini Enterprise Agent Platform, את הענן הפרטי הווירטואלי (VPC), את מסוף Google Cloud ואת Cloud Shell. מומלץ להכיר את Vertex AI Workbench, אבל לא חובה.

דיאגרמת ארכיטקטורה של שימוש ב-Private Service Connect כדי לגשת לפייפליינים לאימון.

מטרות

  • יוצרים שתי רשתות VPC:
    • אחד (vertex-networking-vpc) מיועד לשימוש ב-Agent Platform Pipelines API כדי ליצור ולארח תבנית של צינור עיבוד נתונים לאימון מודל למידת מכונה ולפריסה שלו בנקודת קצה.
    • השני (onprem-dataservice-vpc) מייצג רשת מקומית.
  • מחברים בין שתי רשתות ה-VPC באופן הבא:
    • פורסים שערי HA VPN, מנהרות Cloud VPN ונתבי Cloud Router כדי לחבר בין vertex-networking-vpc ל-onprem-dataservice-vpc.
    • יוצרים נקודת קצה (endpoint) של Private Service Connect ‏(PSC) כדי להעביר בקשות פרטיות ל-API בארכיטקטורת REST של Agent Platform Pipelines.
    • מגדירים פרסום ניתוב בהתאמה אישית של Cloud Router ב-vertex-networking-vpc כדי להודיע על ניתובים לנקודת הקצה של Private Service Connect אל onprem-dataservice-vpc.
  • יוצרים מכונה של Filestore ברשת ה-VPC של onprem-dataservice-vpc ומוסיפים לה נתוני אימון ב-NFS share.
  • יוצרים אפליקציה של חבילת Python למשימת האימון.
  • יוצרים תבנית משימה ב-Agent Platform Pipelines כדי לבצע את הפעולות הבאות:
    • יוצרים ומריצים את משימת האימון על הנתונים מהשיתוף של NFS.
    • מייבאים את המודל המאומן ומעלים אותו למרשם המודלים של Gemini Enterprise Agent Platform.
    • ליצור נקודת קצה ב-Gemini Enterprise Agent Platform לחיזויים אונליין.
    • פורסים את המודל בנקודת הקצה.
  • מעלים את תבנית צינור עיבוד הנתונים למאגר Artifact Registry.
  • משתמשים ב-API בארכיטקטורת REST של Agent Platform Pipelines כדי להפעיל צינור עיבוד נתונים ממארח של שירות נתונים מקומי (on-prem-dataservice-host).

עלויות

במסמך הזה משתמשים ברכיבים הבאים של Google Cloud, והשימוש בהם כרוך בתשלום:

בעזרת מחשבון העלויות אתם יכולים להעריך את העלויות בהתאם לשימוש הצפוי.

משתמשים חדשים של Google Cloud ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

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

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

    כניסה לדף לבחירת הפרויקט

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

    התפקידים שנדרשים כדי לבחור או ליצור פרויקט

    • בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
    • יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים?

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

  4. פותחים את Cloud Shell כדי להריץ את הפקודות שמפורטות במדריך הזה. ‫Cloud Shell היא סביבת מעטפת אינטראקטיבית של Google Cloud , שמאפשרת לנהל את הפרויקטים והמשאבים דרך דפדפן האינטרנט.
  5. ב-Cloud Shell, מגדירים את הפרויקט הנוכחי למזהה הפרויקט ב- Google Cloud ושומרים את אותו מזהה פרויקט במשתנה המעטפת projectid: 
      projectid="PROJECT_ID"
  gcloud config set project ${projectid}
     מחליפים את PROJECT_ID במזהה הפרויקט. במקרה הצורך, אפשר לאתר את מזהה הפרויקט במסוף Google Cloud . מידע נוסף זמין במאמר איתור מזהה הפרויקט.
  6. אם אתם לא הבעלים של הפרויקט, בקשו מהבעלים להקצות לכם את התפקיד אדמין IAM בפרויקט (roles/resourcemanager.projectIamAdmin). אתם צריכים את התפקיד הזה כדי להקצות תפקידי IAM בשלב הבא.

  7. נותנים תפקידים לחשבון המשתמש. מריצים את הפקודה הבאה לכל אחד מהתפקידים הבאים ב-IAM: roles/artifactregistry.admin, roles/artifactregistry.repoAdmin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/file.editor, roles/logging.viewer, roles/logging.admin, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/servicemanagement.quotaAdmin, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/storage.objectAdmin, roles/aiplatform.admin, roles/aiplatform.user, roles/aiplatform.viewer, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/resourcemanager.projectIamAdmin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

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

    • ‫PROJECT_ID: מזהה הפרויקט.
    • ‫USER_IDENTIFIER: המזהה של חשבון המשתמש שלכם. לדוגמה, myemail@example.com.
    • ‫ROLE: התפקיד ב-IAM שאתם נותנים לחשבון המשתמש.

  8. מפעילים את ממשקי ה-API הבאים, אם הם עדיין לא מופעלים: DNS,‏ Artifact Registry,‏ IAM,‏ Compute Engine,‏ Cloud Logging,‏ Network Connectivity,‏ Notebooks,‏ Cloud Filestore,‏ Service Networking,‏ Service Usage, ‏ ו-Agent Platform.

    התפקידים שנדרשים כדי להפעיל ממשקי API

    כדי להפעיל ממשקי API, צריך את ההרשאה serviceusage.services.enable. אם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד "בעלים" (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד "אדמין בממשק 'שימוש בשירות'" (roles/serviceusage.serviceUsageAdmin). כך מקצים תפקידים. 

    gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com logging.googleapis.com networkconnectivity.googleapis.com notebooks.googleapis.com file.googleapis.com servicenetworking.googleapis.com serviceusage.googleapis.com aiplatform.googleapis.com

יצירת רשתות ה-VPC

בקטע הזה, יוצרים שתי רשתות VPC: אחת כדי לגשת ל-Google APIs בשביל Agent Platform Pipelines, והשנייה כדי לדמות רשת מקומית. בכל אחת משתי רשתות ה-VPC, יוצרים Cloud Router ושער Cloud NAT. שער Cloud NAT מספק קישוריות יוצאת למכונות וירטואליות (VM) של Compute Engine ללא כתובות IP חיצוניות.

  1. ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. יוצרים את רשת ה-VPC של vertex-networking-vpc:

    gcloud compute networks create vertex-networking-vpc \
    --subnet-mode custom

  3. ברשת vertex-networking-vpc, יוצרים רשת משנה בשם pipeline-networking-subnet1 עם טווח IPv4 ראשי של 10.0.0.0/24:

    gcloud compute networks subnets create pipeline-networking-subnet1 \
    --range=10.0.0.0/24 \
    --network=vertex-networking-vpc \
    --region=us-central1 \
    --enable-private-ip-google-access

  4. יוצרים את רשת ה-VPC כדי לדמות את הרשת המקומית (onprem-dataservice-vpc):

    gcloud compute networks create onprem-dataservice-vpc \
    --subnet-mode custom

  5. ברשת onprem-dataservice-vpc, יוצרים רשת משנה בשם onprem-dataservice-vpc-subnet1 עם טווח IPv4 ראשי של 172.16.10.0/24:

    gcloud compute networks subnets create onprem-dataservice-vpc-subnet1 \
    --network onprem-dataservice-vpc \
    --range 172.16.10.0/24 \
    --region us-central1 \
    --enable-private-ip-google-access

מוודאים שרשתות ה-VPC מוגדרות בצורה נכונה

  1. במסוף Google Cloud , נכנסים לכרטיסייה Networks in current project בדף רשתות VPC.

    כניסה לדף VPC networks

  2. ברשימת רשתות ה-VPC, מוודאים ששתי הרשתות נוצרו: vertex-networking-vpc ו-onprem-dataservice-vpc.

  3. לוחצים על הכרטיסייה Subnets in current project.

  4. ברשימת רשתות המשנה של ה-VPC, מוודאים שנוצרו רשתות המשנה pipeline-networking-subnet1 ו-onprem-dataservice-vpc-subnet1.

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

בקטע הזה, יוצרים שני שערי HA VPN שמחוברים זה לזה. אחד נמצא ברשת ה-VPC של vertex-networking-vpc. והשני נמצא ברשת ה-VPC של onprem-dataservice-vpc. כל שער מכיל Cloud Router וזוג מנהרות VPN.

יצירת שערי HA VPN

  1. ב-Cloud Shell, יוצרים את שער ה-HA VPN לרשת ה-VPC של vertex-networking-vpc:

    gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
    --network vertex-networking-vpc \
    --region us-central1

  2. יוצרים את שער ה-HA VPN לרשת ה-VPC של onprem-dataservice-vpc:

    gcloud compute vpn-gateways create onprem-vpn-gw1 \
    --network onprem-dataservice-vpc \
    --region us-central1

  3. במסוף Google Cloud , נכנסים לכרטיסייה Cloud VPN Gateways בדף VPN.

    מעבר אל VPN

  4. מוודאים שנוצרו שני השערים (vertex-networking-vpn-gw1 ו-onprem-vpn-gw1) ושלכל שער יש שתי כתובות IP של ממשקים.

יצירת Cloud Routers ושערי Cloud NAT

בכל אחת משתי רשתות ה-VPC, יוצרים שני נתבי Cloud Router: אחד לשימוש עם Cloud NAT ואחד לניהול סשנים של BGP בשביל HA VPN.

  1. ב-Cloud Shell, יוצרים Cloud Router לרשת ה-VPC של vertex-networking-vpc שתשמש ל-VPN:

    gcloud compute routers create vertex-networking-vpc-router1 \
    --region us-central1 \
    --network vertex-networking-vpc \
    --asn 65001

  2. יוצרים Cloud Router לרשת ה-VPC של onprem-dataservice-vpc שתשמש ל-VPN:

    gcloud compute routers create onprem-dataservice-vpc-router1 \
    --region us-central1 \
    --network onprem-dataservice-vpc \
    --asn 65002

  3. יוצרים Cloud Router לרשת ה-VPC של vertex-networking-vpc, שתשמש ל-Cloud NAT:

    gcloud compute routers create cloud-router-us-central1-vertex-nat \
    --network vertex-networking-vpc \
    --region us-central1

  4. מגדירים שער Cloud NAT ב-Cloud Router:

    gcloud compute routers nats create cloud-nat-us-central1 \
    --router=cloud-router-us-central1-vertex-nat \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges \
    --region us-central1

  5. יוצרים Cloud Router לרשת ה-VPC של onprem-dataservice-vpc, שישמש ל-Cloud NAT:

    gcloud compute routers create cloud-router-us-central1-onprem-nat \
    --network onprem-dataservice-vpc \
    --region us-central1

  6. מגדירים שער Cloud NAT ב-Cloud Router:

    gcloud compute routers nats create cloud-nat-us-central1-on-prem \
    --router=cloud-router-us-central1-onprem-nat \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges \
    --region us-central1

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

    כניסה לדף Cloud Routers

  8. ברשימה Cloud Routers, מוודאים שהנתבים הבאים נוצרו:

    • cloud-router-us-central1-onprem-nat
    • cloud-router-us-central1-vertex-nat
    • onprem-dataservice-vpc-router1
    • vertex-networking-vpc-router1

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

  9. ברשימת הנתבים של Cloud Router, לוחצים על cloud-router-us-central1-vertex-nat.

  10. בדף Router details, מוודאים שנוצר שער Cloud NAT של cloud-nat-us-central1.

  11. לוחצים על החץ חזרה כדי לחזור לדף Cloud Routers.

  12. ברשימת הנתבים של Cloud Router, לוחצים על cloud-router-us-central1-onprem-nat.

  13. בדף Router details, מוודאים שנוצר שער Cloud NAT של cloud-nat-us-central1-on-prem.

יצירת מנהרות VPN

  1. ב-Cloud Shell, ברשת vertex-networking-vpc, יוצרים מנהרת VPN בשם vertex-networking-vpc-tunnel0:

    gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
    --peer-gcp-gateway onprem-vpn-gw1 \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
    --router vertex-networking-vpc-router1 \
    --vpn-gateway vertex-networking-vpn-gw1 \
    --interface 0

  2. ברשת vertex-networking-vpc, יוצרים מנהרת VPN בשם vertex-networking-vpc-tunnel1:

    gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
    --peer-gcp-gateway onprem-vpn-gw1 \
    --region us-central1 \
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router vertex-networking-vpc-router1 \
    --vpn-gateway vertex-networking-vpn-gw1 \
    --interface 1

  3. ברשת onprem-dataservice-vpc, יוצרים מנהרת VPN בשם onprem-dataservice-vpc-tunnel0:

    gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel0 \
    --peer-gcp-gateway vertex-networking-vpn-gw1 \
    --region us-central1\
    --ike-version 2 \
    --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
    --router onprem-dataservice-vpc-router1 \
    --vpn-gateway onprem-vpn-gw1 \
    --interface 0

  4. ברשת onprem-dataservice-vpc, יוצרים מנהרת VPN בשם onprem-dataservice-vpc-tunnel1:

    gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel1 \
    --peer-gcp-gateway vertex-networking-vpn-gw1 \
    --region us-central1\
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router onprem-dataservice-vpc-router1 \
    --vpn-gateway onprem-vpn-gw1 \
    --interface 1

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

    מעבר אל VPN

  6. ברשימת מנהרות ה-VPN, מוודאים שנוצרו ארבע מנהרות VPN.

יצירת סשנים של BGP

ב-Cloud Router משתמשים בפרוטוקול Border Gateway Protocol ‏ (BGP) כדי להחליף נתיבים בין רשת ה-VPC (במקרה הזה, vertex-networking-vpc) לבין הרשת המקומית (המיוצגת על ידי onprem-dataservice-vpc). ב-Cloud Router מגדירים ממשק ו-BGP שכנה לנתב המקומי. הממשק והגדרת ה-BGP peer יוצרים יחד סשן BGP. בקטע הזה יוצרים שני סשנים של BGP ל-vertex-networking-vpc ושניים ל-onprem-dataservice-vpc.

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

הגדרת סשנים של BGP עבור vertex-networking-vpc

  1. ב-Cloud Shell, ברשת vertex-networking-vpc, יוצרים ממשק BGP בשביל vertex-networking-vpc-tunnel0:

    gcloud compute routers add-interface vertex-networking-vpc-router1 \
    --interface-name if-tunnel0-to-onprem \
    --ip-address 169.254.0.1 \
    --mask-length 30 \
    --vpn-tunnel vertex-networking-vpc-tunnel0 \
    --region us-central1

  2. ברשת vertex-networking-vpc, יוצרים קישור בין רשתות שכנות באמצעות BGP למנהרה bgp-onprem-tunnel0:

    gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
    --peer-name bgp-onprem-tunnel0 \
    --interface if-tunnel0-to-onprem \
    --peer-ip-address 169.254.0.2 \
    --peer-asn 65002 \
    --region us-central1

  3. ברשת vertex-networking-vpc, יוצרים ממשק BGP ל-vertex-networking-vpc-tunnel1:

    gcloud compute routers add-interface vertex-networking-vpc-router1 \
    --interface-name if-tunnel1-to-onprem \
    --ip-address 169.254.1.1 \
    --mask-length 30 \
    --vpn-tunnel vertex-networking-vpc-tunnel1 \
    --region us-central1

  4. ברשת vertex-networking-vpc, יוצרים קישור בין רשתות שכנות באמצעות BGP למנהרה bgp-onprem-tunnel1:

    gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
    --peer-name bgp-onprem-tunnel1 \
    --interface if-tunnel1-to-onprem \
    --peer-ip-address 169.254.1.2 \
    --peer-asn 65002 \
    --region us-central1

הגדרת סשנים של BGP עבור onprem-dataservice-vpc

  1. ברשת onprem-dataservice-vpc, יוצרים ממשק BGP ל-onprem-dataservice-vpc-tunnel0:

    gcloud compute routers add-interface onprem-dataservice-vpc-router1 \
    --interface-name if-tunnel0-to-vertex-networking-vpc \
    --ip-address 169.254.0.2 \
    --mask-length 30 \
    --vpn-tunnel onprem-dataservice-vpc-tunnel0 \
    --region us-central1

  2. ברשת onprem-dataservice-vpc, יוצרים קישור בין רשתות שכנות באמצעות BGP למנהרה bgp-vertex-networking-vpc-tunnel0:

    gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
    --peer-name bgp-vertex-networking-vpc-tunnel0 \
    --interface if-tunnel0-to-vertex-networking-vpc \
    --peer-ip-address 169.254.0.1 \
    --peer-asn 65001 \
    --region us-central1

  3. ברשת onprem-dataservice-vpc, יוצרים ממשק BGP ל-onprem-dataservice-vpc-tunnel1:

    gcloud compute routers add-interface onprem-dataservice-vpc-router1  \
    --interface-name if-tunnel1-to-vertex-networking-vpc \
    --ip-address 169.254.1.2 \
    --mask-length 30 \
    --vpn-tunnel onprem-dataservice-vpc-tunnel1 \
    --region us-central1

  4. ברשת onprem-dataservice-vpc, יוצרים קישור בין רשתות שכנות באמצעות BGP למנהרה bgp-vertex-networking-vpc-tunnel1:

    gcloud compute routers add-bgp-peer onprem-dataservice-vpc-router1 \
    --peer-name bgp-vertex-networking-vpc-tunnel1 \
    --interface if-tunnel1-to-vertex-networking-vpc \
    --peer-ip-address 169.254.1.1 \
    --peer-asn 65001 \
    --region us-central1

אימות היצירה של סשן BGP

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

    מעבר אל VPN

  2. ברשימת מנהרות ה-VPN, מוודאים שהערך בעמודה BGP session status של כל אחת מהמנהרות השתנה מ-Configure BGP session ל-BGP established. יכול להיות שתצטרכו לרענן את הכרטיסייה של מסוף Google Cloud בדפדפן כדי לראות את הערכים החדשים.

אימות של onprem-dataservice-vpc הנתיבים שנלמדו

  1. נכנסים לדף VPC networks במסוף Google Cloud .

    כניסה לדף VPC networks

  2. ברשימת רשתות ה-VPC, לוחצים על onprem-dataservice-vpc.

  3. לוחצים על הכרטיסייה מסלולים.

  4. בוחרים באפשרות us-central1 (Iowa) ברשימה Region ולוחצים על View.

  5. בעמודה Destination IP range, מוודאים שטווח כתובות ה-IP של רשת המשנה של pipeline-networking-subnet1 (10.0.0.0/24) מופיע פעמיים.

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

אימות של vertex-networking-vpc הנתיבים שנלמדו

  1. לוחצים על החץ חזרה כדי לחזור לדף רשתות VPC.

  2. ברשימת רשתות ה-VPC, לוחצים על vertex-networking-vpc.

  3. לוחצים על הכרטיסייה מסלולים.

  4. בוחרים באפשרות us-central1 (Iowa) ברשימה Region ולוחצים על View.

  5. בעמודה Destination IP range, מוודאים שטווח ה-IP של תת-הרשת onprem-dataservice-vpc-subnet1 (172.16.10.0/24) מופיע פעמיים.

יצירת נקודת קצה מסוג Private Service Connect לממשקי Google API

בקטע הזה, יוצרים נקודת קצה (endpoint) של Private Service Connect לממשקי Google API, שבה תשתמשו כדי לגשת ל-API בארכיטקטורת REST של Agent Platform Pipelines מהרשת המקומית.

  1. ב-Cloud Shell, שומרים כתובת IP של נקודת קצה (endpoint) של צרכן, שתשמש לגישה ל-Google APIs:

    gcloud compute addresses create psc-googleapi-ip \
    --global \
    --purpose=PRIVATE_SERVICE_CONNECT \
    --addresses=192.168.0.1 \
    --network=vertex-networking-vpc

  2. יוצרים כלל העברה כדי לקשר את נקודת הקצה לממשקי ה-API ולשירותים של Google.

    gcloud compute forwarding-rules create pscvertex \
   --global \
   --network=vertex-networking-vpc \
   --address=psc-googleapi-ip \
   --target-google-apis-bundle=all-apis

יצירת פרסומי ניתוב בהתאמה אישית עבור vertex-networking-vpc

בקטע הזה, יוצרים פרסום ניתוב בהתאמה אישית ל-vertex-networking-vpc-router1 (ה-Cloud Router של vertex-networking-vpc) כדי לפרסם את כתובת ה-IP של נקודת הקצה של ה-PSC לרשת ה-VPC של onprem-dataservice-vpc.

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

    כניסה לדף Cloud Routers

  2. ברשימת הנתבים של Cloud Router, לוחצים על vertex-networking-vpc-router1.

  3. בדף Router details לוחצים על Edit.

  4. בקטע Advertised routes, בוחרים באפשרות Create custom routes בשדה Routes.

  5. מסמנים את התיבה Advertise all subnets visible to the Cloud Router כדי להמשיך לפרסם את רשתות המשנה שזמינות ל-Cloud Router. הפעלת האפשרות הזו מחקה את ההתנהגות של Cloud Router במצב פרסום ברירת מחדל.

  6. לוחצים על הוספת נתיב בהתאמה אישית.

  7. בשדה Source, בוחרים באפשרות Custom IP range.

  8. בשדה טווח כתובות IP, מזינים את כתובת ה-IP הבאה:

    192.168.0.1

  9. בשדה Description, מזינים את הטקסט הבא:

    Custom route to advertise Private Service Connect endpoint IP address

  10. לוחצים על סיום ואז על שמירה.

מוודאים ש-onprem-dataservice-vpc למד את המסלולים שפורסמו

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

    לדף Routes

  2. בכרטיסייה Effective routes, מבצעים את הפעולות הבאות:

    1. בשדה Network, בוחרים באפשרות onprem-dataservice-vpc.
    2. בשדה Region, בוחרים באפשרות us-central1 (Iowa).
    3. לוחצים על הצגה.

    4. ברשימת הנתיבים, מוודאים שיש שני פריטים שהשמות שלהם מתחילים ב-onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 ושני פריטים שהשמות שלהם מתחילים ב-onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.

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

    5. מוודאים שבשתיים מהרשומות טווח כתובות ה-IP של היעד הוא 192.168.0.1/32, ובשתיים מהרשומות טווח כתובות ה-IP של היעד הוא 10.0.0.0/24.

יצירת מכונה וירטואלית ב-onprem-dataservice-vpc

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

יצירת חשבון שירות בניהול המשתמשים למכונה הווירטואלית

  1. ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. יוצרים חשבון שירות בשם onprem-user-managed-sa:

    gcloud iam service-accounts create onprem-user-managed-sa \
    --display-name="onprem-user-managed-sa"

  3. מקצים לחשבון השירות את התפקיד Agent Platform User (roles/aiplatform.user):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/aiplatform.user"

  4. מקצים את התפקיד צפייה ב-Agent Platform‏ (roles/aiplatform.viewer):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/aiplatform.viewer"

  5. מקצים את התפקיד עריכת Filestore‏ (roles/file.editor):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/file.editor"

  6. מקצים את התפקיד אדמין של חשבון שירות (roles/iam.serviceAccountAdmin):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountAdmin"

  7. מקצים את התפקיד משתמש בחשבון שירות (roles/iam.serviceAccountUser):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

  8. מקצים את התפקיד צפייה ב-Artifact Registry‏ (roles/artifactregistry.reader):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader"

  9. מקצים את התפקיד Storage Object Admin (roles/storage.objectAdmin):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/storage.objectAdmin"

  10. מקצים את התפקיד Logging Admin (roles/logging.admin):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/logging.admin"

יצירת מכונת VM של on-prem-dataservice-host

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

  1. ב-Cloud Shell, יוצרים את המכונה הווירטואלית on-prem-dataservice-host:

    gcloud compute instances create on-prem-dataservice-host \
    --zone=us-central1-a \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --subnet=onprem-dataservice-vpc-subnet1 \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --no-address \
    --shielded-secure-boot \
    --service-account=onprem-user-managed-sa@$projectid.iam.gserviceaccount.com \
    --metadata startup-script="#! /bin/bash
sudo apt-get update
sudo apt-get install tcpdump dnsutils -y"

  2. יוצרים כלל של חומת אש שמאפשר ל-IAP להתחבר למכונה הווירטואלית:

    gcloud compute firewall-rules create ssh-iap-on-prem-vpc \
    --network onprem-dataservice-vpc \
    --allow tcp:22 \
    --source-ranges=35.235.240.0/20

עדכון הקובץ /etc/hosts כך שיפנה לנקודת הקצה של ה-PSC

בקטע הזה, מוסיפים שורה לקובץ /etc/hosts כדי לגרום לבקשות שנשלחות לנקודת הקצה של השירות הציבורי (us-central1-aiplatform.googleapis.com) להיות מנותבות מחדש לנקודת הקצה של ה-PSC‏ (192.168.0.1).

  1. ב-Cloud Shell, מתחברים למכונה הווירטואלית on-prem-dataservice-host באמצעות IAP:

    gcloud compute ssh on-prem-dataservice-host \
  --zone=us-central1-a \
  --tunnel-through-iap

  2. במכונה הווירטואלית on-prem-dataservice-host, משתמשים בכלי לעריכת טקסט כמו vim או nano כדי לפתוח את הקובץ /etc/hosts, לדוגמה:

    sudo vim /etc/hosts

  3. מוסיפים את השורה הבאה לקובץ:

    192.168.0.1 us-central1-aiplatform.googleapis.com

    השורה הזו מקצה את כתובת ה-IP של נקודת הקצה של ה-PSC (192.168.0.1) לשם דומיין שמוגדר במלואו עבור Gemini Enterprise Agent Platform Google API (us-central1-aiplatform.googleapis.com).

    הקובץ הערוך אמור להיראות כך:

    127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
172.16.10.6 on-prem-dataservice-host.us-central1-a.c.PROJECT_ID.internal on-prem-dataservice-host  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

  4. שומרים את הקובץ באופן הבא:

    • אם אתם משתמשים ב-vim, לחצו על המקש Esc ואז הקלידו :wq כדי לשמור את הקובץ ולצאת.
    • אם אתם משתמשים ב-nano, מקלידים Control+O ולוחצים על Enter כדי לשמור את הקובץ, ואז מקלידים Control+X כדי לצאת.

  5. שולחים פינג לנקודת קצה ל-API של Agent Platform באופן הבא:

    ping us-central1-aiplatform.googleapis.com

    הפלט הבא אמור להתקבל באמצעות הפקודה ping: ‫192.168.0.1 היא כתובת ה-IP של נקודת הקצה של ה-PSC:

    PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.

  6. מקלידים Control+C כדי לצאת מ-ping.

  7. מקלידים exit כדי לצאת ממכונת ה-VM‏ on-prem-dataservice-host ולחזור להנחיה של Cloud Shell.

הגדרת רשתות למכונה של Filestore

בקטע הזה תפעילו גישה לשירותים פרטיים ברשת ה-VPC, כהכנה ליצירת מכונה של Filestore וטעינה שלה כשיתוף של מערכת קובצי רשת (NFS). כדי להבין מה אתם עושים בקטע הזה ובקטע הבא, קראו את המאמרים התקנת שיתוף NFS לאימון בהתאמה אישית והגדרת קישור בין רשתות VPC שכנות.

הפעלת גישה לשירותים פרטיים ברשת VPC

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

  1. ב-Cloud Shell, מגדירים טווח שמור של כתובות IP באמצעות gcloud compute addresses create:

    gcloud compute addresses create filestore-subnet \
   --global \
   --purpose=VPC_PEERING \
   --addresses=10.243.208.0 \
   --prefix-length=24 \
   --description="filestore subnet" \
   --network=onprem-dataservice-vpc

  2. יוצרים חיבור בין רשתות שכנות (peering) בין רשת ה-VPC של onprem-dataservice-vpc לבין Service Networking של Google, באמצעות gcloud services vpc-peerings connect:

    gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=filestore-subnet \
    --network=onprem-dataservice-vpc

  3. מעדכנים את הקישור בין רשתות VPC שכנות כדי לאפשר ייבוא וייצוא של נתיבים שנלמדו בהתאמה אישית:

    gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=onprem-dataservice-vpc \
    --import-custom-routes \
    --export-custom-routes

  4. במסוף Google Cloud , נכנסים לדף קישור בין רשתות שכנות (peering) של רשת VPC.

    מעבר לקישור בין רשתות VPC שכנות (peering)

  5. ברשימת הקישורים בין רשתות VPC שכנות, מוודאים שיש רשומה לקישור בין servicenetworking.googleapis.com לבין רשת ה-VPC של onprem-dataservice-vpc.

יצירת פרסומי ניתוב (route advertisement) בהתאמה אישית ל-filestore-subnet

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

    כניסה לדף Cloud Routers

  2. ברשימת הנתבים של Cloud Router, לוחצים על onprem-dataservice-vpc-router1.

  3. בדף Router details לוחצים על Edit.

  4. בקטע Advertised routes, בוחרים באפשרות Create custom routes בשדה Routes.

  5. מסמנים את התיבה Advertise all subnets visible to the Cloud Router כדי להמשיך לפרסם את רשתות המשנה שזמינות ל-Cloud Router. הפעלת האפשרות הזו מחקה את ההתנהגות של Cloud Router במצב פרסום ברירת מחדל.

  6. לוחצים על הוספת נתיב בהתאמה אישית.

  7. בשדה Source, בוחרים באפשרות Custom IP range.

  8. בשדה טווח כתובות IP, מזינים את טווח כתובות ה-IP הבא:

    10.243.208.0/24

  9. בשדה Description, מזינים את הטקסט הבא:

    Filestore reserved IP address range

  10. לוחצים על סיום ואז על שמירה.

יוצרים את מכונת Filestore ברשת onprem-dataservice-vpc

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

יצירת מכונה של Filestore

  1. נכנסים לדף Filestore Instances במסוף Google Cloud .

    כניסה לדף Filestore Instances

  2. לוחצים על Create instance ומגדירים את המכונה באופן הבא:

    • מגדירים את מזהה המכונה באופן הבא:

      image-data-instance

    • מגדירים את Instance type בתור Basic.

    • מגדירים את Storage type בתור HDD.

    • מגדירים את Allocate capacity ל-1 TiB.

    • מגדירים את Region לערך us-central1 ואת Zone לערך us-central1-c.

    • מגדירים את רשת VPC לערך onprem-dataservice-vpc.

    • מגדירים את Allocated IP range ל-Use an existing allocated IP range ובוחרים את filestore-subnet.

    • מגדירים את File share name לערך הבא:

      vol1

    • מגדירים את בקרת גישה ל-מתן גישה לכל הלקוחות ברשת VPC.

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

  4. שימו לב לכתובת ה-IP של המכונה החדשה ב-Filestore. יכול להיות שתצטרכו לרענן את הכרטיסייה של מסוף Google Cloud בדפדפן כדי לראות את המכונה החדשה.

טעינת הקובץ המשותף של Filestore

  1. ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. מתחברים למכונה הווירטואלית on-prem-dataservice-host:

    gcloud compute ssh on-prem-dataservice-host \
    --zone=us-central1-a \
    --tunnel-through-iap

  3. מתקינים את חבילת ה-NFS במכונה הווירטואלית:

    sudo apt-get update -y
sudo apt-get -y install nfs-common

  4. יוצרים ספריית טעינה לקובץ המשותף ב-Filestore:

    sudo mkdir -p /mnt/nfs

  5. מפעילים את שיתוף הקבצים, ומחליפים את FILESTORE_INSTANCE_IP בכתובת ה-IP של מכונת Filestore:

    sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs

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

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

    df -h

    מוודאים ששיתוף הקבצים של /mnt/nfs מופיע בתוצאה:

    Filesystem           Size  Used Avail Use% Mounted on
udev                 1.8G     0  1.8G   0% /dev
tmpfs                368M  396K  368M   1% /run
/dev/sda1            9.7G  1.9G  7.3G  21% /
tmpfs                1.8G     0  1.8G   0% /dev/shm
tmpfs                5.0M     0  5.0M   0% /run/lock
/dev/sda15           124M   11M  114M   9% /boot/efi
tmpfs                368M     0  368M   0% /run/user
10.243.208.2:/vol1  1007G     0  956G   0% /mnt/nfs

  7. כדי להפוך את הקובץ לנגיש, משנים את ההרשאות:

    sudo chmod go+rw /mnt/nfs

הורדת מערך הנתונים לשיתוף הקבצים

  1. במכונה הווירטואלית on-prem-dataservice-host, מורידים את קבוצת הנתונים להתקן רשת לשיתוף קבצים:

    gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive

    ההורדה נמשכת כמה דקות.

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

    sudo du -sh /mnt/nfs

    הפלט הצפוי:

    104M    /mnt/nfs

  3. מקלידים exit כדי לצאת ממכונת ה-VM‏ on-prem-dataservice-host ולחזור להנחיה של Cloud Shell.

יצירת קטגוריית אחסון זמנית לפייפליין

הפריטים של הרצות צינורות עיבוד הנתונים ב-Agent Platform Pipelines נשמרים באמצעות Cloud Storage. לפני שמריצים את צינור עיבוד הנתונים, צריך ליצור קטגוריה של Cloud Storage להכנת הרצות של צינור עיבוד הנתונים.

יוצרים קטגוריה של Cloud Storage ב-Cloud Shell:

gcloud storage buckets create gs://pipelines-staging-bucket-$projectid --location=us-central1

יצירת חשבון שירות שמנוהל על ידי משתמשים ב-Vertex AI Workbench

  1. ב-Cloud Shell, יוצרים חשבון שירות:

    gcloud iam service-accounts create workbench-sa \
    --display-name="workbench-sa"

  2. מקצים לחשבון השירות את התפקיד Agent Platform User (roles/aiplatform.user):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/aiplatform.user"

  3. מקצים את התפקיד אדמין של Artifact Registry‏ (artifactregistry.admin):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.admin"

  4. מקצים את התפקיד Storage Admin (storage.admin):

    gcloud projects add-iam-policy-binding $projectid \
    --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/storage.admin"

יצירת אפליקציית האימון ב-Python

בקטע הזה יוצרים מכונה של Vertex AI Workbench ומשתמשים בה כדי ליצור חבילת אפליקציה לאימון בהתאמה אישית ב-Python.

יצירת מכונה של Vertex AI Workbench

  1. נכנסים לדף Vertex AI Workbench במסוף Google Cloud ולוחצים על הכרטיסייה Instances.

    כניסה ל-Agent Platform Workbench

  2. לוחצים על  Create new ואז על Advanced options.

    הדף New instance נפתח.

  3. בקטע Details בדף New instance, ממלאים את הפרטים הבאים של המכונה החדשה ולוחצים על Continue:

    • ‫Name: מזינים את הפרטים הבאים, ומחליפים את PROJECT_ID במזהה הפרויקט:

      pipeline-tutorial-PROJECT_ID

    • Region: בוחרים באפשרות us-central1.

    • ‫Zone: בוחרים באפשרות us-central1-a.

    • מבטלים את הסימון בתיבה Enable Dataproc Serverless Interactive Sessions.

  4. בקטע Environment, לוחצים על Continue.

  5. בקטע Machine type, מזינים את הפרטים הבאים ולוחצים על Continue:

    • ‫Machine type: בוחרים באפשרות N1, ואז בוחרים באפשרות n1-standard-4 בתפריט Machine type.

    • מכונה וירטואלית מוגנת: מסמנים את תיבות הסימון הבאות:

      • אתחול מאובטח
      • מודול פלטפורמה וירטואלית מהימנה (vTPM)
      • מעקב אחרי תקינות

  6. בקטע Disks, מוודאים שהאפשרות Google-managed encryption key מסומנת ולוחצים על Continue:

  7. בקטע Networking, מזינים את הפרטים הבאים ולוחצים על Continue:

    • ‫Networking: בוחרים באפשרות Network in this project ומבצעים את הפעולות הבאות:

      1. בשדה Network, בוחרים באפשרות vertex-networking-vpc.

      2. בשדה Subnetwork, בוחרים באפשרות pipeline-networking-subnet1.

      3. מבטלים את הסימון של התיבה Assign external IP address. אם לא מקצים כתובת IP חיצונית, המכונה לא יכולה לקבל תקשורת לא רצויה מהאינטרנט או מרשתות VPC אחרות.

      4. מסמנים את התיבה מתן הרשאת גישה.

  8. בקטע IAM and security, מזינים את הפרטים הבאים ולוחצים על Continue:

    • ‫IAM ואבטחה: כדי לתת למשתמש יחיד גישה לממשק JupyterLab של המכונה, מבצעים את השלבים הבאים:

      1. בוחרים באפשרות Service account.
      2. מבטלים את הסימון בתיבה Use Compute Engine default service account. השלב הזה חשוב כי לחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine (ולכן גם למשתמש היחיד שציינתם) יכול להיות תפקיד עריכה (roles/editor) בפרויקט.

      3. בשדה Service account email, מזינים את הערך הבא, ומחליפים את PROJECT_ID במזהה הפרויקט:

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com

        (זו כתובת האימייל של חשבון השירות בהתאמה אישית שיצרתם קודם). לחשבון השירות הזה יש הרשאות מוגבלות.

        איך נותנים גישה לממשק JupyterLab של מכונה ב-Agent Platform Workbench

    • אפשרויות אבטחה: מבטלים את הסימון של התיבה הבאה:

      • גישת רוט (Root) למכונה

      מסמנים את תיבת הסימון הבאה:

      מבטלים את הסימון בתיבה הבאה:

      • הורדת קבצים

      מסמנים את תיבת הסימון הבאה, אלא אם אתם נמצאים בסביבת ייצור:

      • גישה לטרמינל: מאפשרת גישה לטרמינל של המכונה מתוך ממשק המשתמש של JupyterLab.

  9. בקטע System health, מבטלים את הסימון של Environment auto-upgrade ומזינים את הפרטים הבאים:

    • בקטע דיווח, מסמנים את התיבות הבאות:

      • דיווח על תקינות המערכת
      • דיווח על מדדים מותאמים אישית ל-Cloud Monitoring
      • התקנת Cloud Monitoring
      • דיווח על סטטוס ה-DNS של דומיינים נדרשים של Google

  10. לוחצים על Create וממתינים כמה דקות עד שנוצר המכונה של Agent Platform Workbench.

הרצת אפליקציית האימון במכונה של Agent Platform Workbench

  1. במסוף Google Cloud , נכנסים לכרטיסייה Instances בדף Gemini Enterprise Agent Platform Workbench.

    כניסה ל-Agent Platform Workbench

  2. ליד השם של מכונת Workbench ב-Agent Platform (pipeline-tutorial-PROJECT_ID), כאשר PROJECT_ID הוא מזהה הפרויקט, לוחצים על Open JupyterLab.

    המכונה של Agent Platform Workbench נפתחת ב-JupyterLab.

  3. לוחצים על קובץ > חדש > מסוף.

  4. בטרמינל של JupyterLab (לא ב-Cloud Shell), מגדירים משתנה סביבה לפרויקט. מחליפים את PROJECT_ID במזהה הפרויקט:

    projectid=PROJECT_ID

  5. יוצרים את ספריות האם של אפליקציית האימון (עדיין בטרמינל של JupyterLab):

    mkdir fungi_training_package
mkdir fungi_training_package/trainer

  6. ב- File Browser, לוחצים לחיצה כפולה על התיקייה fungi_training_package ואז לוחצים לחיצה כפולה על התיקייה trainer.

  7. ב- File Browser, לוחצים לחיצה ימנית על רשימת הקבצים הריקה (מתחת לכותרת Name) ובוחרים באפשרות New file.

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

  9. משנים את שם הקובץ מ-untitled.txt ל-task.py.

  10. לוחצים לחיצה כפולה על הקובץ task.py כדי לפתוח אותו.

  11. מעתיקים את הקוד הבא אל task.py:

    # Import the libraries
import tensorflow as tf
from tensorflow.python.client import device_lib
import argparse
import os
import sys
# add parser arguments
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', dest='dataset_dir', type=str,
                 help='Dir to access dataset.')
parser.add_argument('--model-dir', dest='model_dir', default=os.getenv("AIP_MODEL_DIR"), type=str,
                 help='Dir to save the model.')
parser.add_argument('--epochs', dest='epochs', default=10, type=int,
                 help='Number of epochs.')
parser.add_argument('--batch-size', dest='batch_size', default=32, type=int,
                 help='Number of images per batch.')
parser.add_argument('--distribute', dest='distribute', default='single', type=str,
                 help='distributed training strategy.')
args = parser.parse_args()
# print the tf version and config
print('Python Version = {}'.format(sys.version))
print('TensorFlow Version = {}'.format(tf.__version__))
print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
print('DEVICES', device_lib.list_local_devices())

# Single Machine, single compute device
if args.distribute == 'single':
    if tf.test.is_gpu_available():
        strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
    else:
        strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
# Single Machine, multiple compute device
elif args.distribute == 'mirror':
    strategy = tf.distribute.MirroredStrategy()
# Multiple Machine, multiple compute device
elif args.distribute == 'multi':
    strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()

# Multi-worker configuration
print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))

# Preparing dataset
BUFFER_SIZE = 1000
IMG_HEIGHT = 224
IMG_WIDTH = 224

def make_datasets_batched(dataset_path, global_batch_size):
    # Configure the training data generator
    train_data_dir = os.path.join(dataset_path,"train/")
    train_ds = tf.keras.utils.image_dataset_from_directory(
                         train_data_dir,
                         seed=36,
                         image_size=(IMG_HEIGHT, IMG_WIDTH),
                         batch_size=global_batch_size
               )
    # Configure the validation data generator
    val_data_dir = os.path.join(dataset_path,"valid/")
    val_ds = tf.keras.utils.image_dataset_from_directory(
                       val_data_dir,
                       seed=36,
                       image_size=(IMG_HEIGHT, IMG_WIDTH),
                       batch_size=global_batch_size
             )
    # get the number of classes in the data
    num_classes = len(train_ds.class_names)

    # Configure the dataset for performance
    AUTOTUNE = tf.data.AUTOTUNE
    train_ds = train_ds.cache().shuffle(BUFFER_SIZE).prefetch(buffer_size=AUTOTUNE)
    val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
    return train_ds, val_ds, num_classes

# Build the Keras model
def build_and_compile_cnn_model(num_classes):
    # build a CNN model
    model = tf.keras.models.Sequential([
      tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
      tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(num_classes)
    ])
    # compile the CNN model
    model.compile(optimizer='adam',
               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
               metrics=['accuracy'])
    return model

# Get the strategy data
NUM_WORKERS = strategy.num_replicas_in_sync
# Here the batch size scales up by number of workers
GLOBAL_BATCH_SIZE = args.batch_size * NUM_WORKERS

# Create dataset generator objects
train_ds, val_ds, num_classes = make_datasets_batched(args.dataset_dir, GLOBAL_BATCH_SIZE)
# Compile the model
with strategy.scope():
    # Creation of dataset, and model building/compiling need to be within
    # `strategy.scope()`.
    model = build_and_compile_cnn_model(num_classes)
# fit the model on the data
history = model.fit(train_ds, validation_data=val_ds, epochs=args.epochs)
# save the model to the output dir
model.save(args.model_dir)

  12. לוחצים על קובץ > שמירת קובץ Python.

  13. בטרמינל של JupyterLab, יוצרים קובץ __init__.py בכל ספריית משנה כדי להפוך אותה לחבילה:

    touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py

  14. ב דפדפן הקבצים, לוחצים לחיצה כפולה על התיקייה fungi_training_package.

  15. בוחרים באפשרות File > New > Python file (קובץ > חדש > קובץ Python).

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

  17. משנים את שם הקובץ מ-untitled.py ל-setup.py.

  18. לוחצים לחיצה כפולה על הקובץ setup.py כדי לפתוח אותו.

  19. מעתיקים את הקוד הבא אל setup.py:

    from setuptools import find_packages
from setuptools import setup
setup(
   name='trainer',
   version='0.1',
   packages=find_packages(),
   include_package_data=True,
   description='Training application package for fungi-classification.'
)

  20. לוחצים על קובץ > שמירת קובץ Python.

  21. במסוף, עוברים לספרייה fungi_training_package:

    cd fungi_training_package

  22. משתמשים בפקודה sdist כדי ליצור את הפצת המקור של אפליקציית האימון:

    python setup.py sdist --formats=gztar

  23. עוברים לספריית האם:

    cd ..

  24. מוודאים שאתם בספרייה הנכונה:

    pwd

    הפלט אמור להיראות כך:

    /home/jupyter

  25. מעתיקים את חבילת Python לקטגוריית ה-Staging:

    gcloud storage cp fungi_training_package/dist/trainer-0.1.tar.gz gs://pipelines-staging-bucket-$projectid/training_package/

  26. מוודאים שהחבילה נמצאת בקטגוריית ה-Staging:

    gcloud storage ls gs://pipelines-staging-bucket-$projectid/training_package

    הפלט שיתקבל:

    gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz

יצירת החיבור של Service Networking ל-Agent Platform Pipelines

בקטע הזה, יוצרים חיבור של Service Networking שמשמש להגדרת שירותים של ספקים שמחוברים לרשת ה-VPC של vertex-networking-vpc באמצעות קישור בין רשתות VPC שכנות (peering). מידע נוסף זמין במאמר קישור בין רשתות VPC שכנות.

  1. ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. מגדירים טווח כתובות IP שמור באמצעות gcloud compute addresses create:

    gcloud compute addresses create vertex-pipeline-subnet \
    --global \
    --purpose=VPC_PEERING \
    --addresses=192.168.10.0 \
    --prefix-length=24 \
    --description="pipeline subnet" \
    --network=vertex-networking-vpc

  3. יוצרים חיבור בין רשתות שכנות (peering) בין רשת ה-VPC של vertex-networking-vpc לבין Service Networking של Google, באמצעות gcloud services vpc-peerings connect:

    gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=vertex-pipeline-subnet \
    --network=vertex-networking-vpc

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

    gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=vertex-networking-vpc \
    --import-custom-routes \
    --export-custom-routes

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

    כניסה לדף Cloud Routers

  2. ברשימת הנתבים של Cloud Router, לוחצים על vertex-networking-vpc-router1.

  3. בדף Router details לוחצים על Edit.

  4. לוחצים על הוספת נתיב בהתאמה אישית.

  5. בשדה Source, בוחרים באפשרות Custom IP range.

  6. בשדה טווח כתובות IP, מזינים את טווח כתובות ה-IP הבא:

    192.168.10.0/24

  7. בשדה Description, מזינים את הטקסט הבא:

    Agent Platform Pipelines reserved subnet

  8. לוחצים על סיום ואז על שמירה.

יצירת תבנית של צינור עיבוד נתונים והעלאה שלה ל-Artifact Registry

בקטע הזה יוצרים ומעלים תבנית צינור עיבוד נתונים של Kubeflow Pipelines ‏ (KFP). התבנית הזו מכילה הגדרה של תהליך עבודה שאפשר להשתמש בה כמה פעמים, על ידי משתמש אחד או כמה משתמשים.

הגדרה והידור של צינור עיבוד הנתונים

  1. ב-Jupyterlab, ב- File Browser, לוחצים לחיצה כפולה על התיקייה ברמה העליונה.

  2. בוחרים באפשרות File > New > Notebook.

  3. בתפריט Select Kernel, בוחרים באפשרות Python 3 (ipykernel) ולוחצים על Select.

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

    !python -m pip install --upgrade pip

  5. מריצים את הפקודה הבאה כדי להתקין את ערכת ה-SDK של רכיבי צינור עיבוד הנתונים של Google Cloud מאינדקס החבילות של Python ‏ (PyPI):

    !pip install --upgrade google-cloud-pipeline-components

  6. בסיום ההתקנה, בוחרים באפשרות Kernel > Restart kernel כדי להפעיל מחדש את הליבה ולוודא שהספרייה זמינה לייבוא.

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

    from kfp import dsl
# define the train-deploy pipeline
@dsl.pipeline(name="custom-image-classification-pipeline")
def custom_image_classification_pipeline(
 project: str,
 training_job_display_name: str,
 worker_pool_specs: list,
 base_output_dir: str,
 model_artifact_uri: str,
 prediction_container_uri: str,
 model_display_name: str,
 endpoint_display_name: str,
 network: str = '',
 location: str="us-central1",
 serving_machine_type: str="n1-standard-4",
 serving_min_replica_count: int=1,
 serving_max_replica_count: int=1
 ):
 from google_cloud_pipeline_components.types import artifact_types
 from google_cloud_pipeline_components.v1.custom_job import CustomTrainingJobOp
 from google_cloud_pipeline_components.v1.model import ModelUploadOp
 from google_cloud_pipeline_components.v1.endpoint import (EndpointCreateOp,
                                                           ModelDeployOp)
 from kfp.dsl import importer

 # Train the model task
 custom_job_task = CustomTrainingJobOp(
      project=project,
      display_name=training_job_display_name,
      worker_pool_specs=worker_pool_specs,
      base_output_directory=base_output_dir,
      location=location,
      network=network
      )

 # Import the model task
 import_unmanaged_model_task = importer(
      artifact_uri=model_artifact_uri,
      artifact_class=artifact_types.UnmanagedContainerModel,
      metadata={
         "containerSpec": {
            "imageUri": prediction_container_uri,
            },
         },
         ).after(custom_job_task)
 # Model upload task
 model_upload_op = ModelUploadOp(
      project=project,
      display_name=model_display_name,
      unmanaged_container_model=import_unmanaged_model_task.outputs["artifact"],
      )
 model_upload_op.after(import_unmanaged_model_task)
 # Create Endpoint task
 endpoint_create_op = EndpointCreateOp(
      project=project,
      display_name=endpoint_display_name,
      )
 # Deploy the model to the endpoint
 ModelDeployOp(
      endpoint=endpoint_create_op.outputs["endpoint"],
      model=model_upload_op.outputs["model"],
      dedicated_resources_machine_type=serving_machine_type,
      dedicated_resources_min_replica_count=serving_min_replica_count,
      dedicated_resources_max_replica_count=serving_max_replica_count,
      )

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

    from kfp import compiler
PIPELINE_FILE = "pipeline_config.yaml"
compiler.Compiler().compile(
    pipeline_func=custom_image_classification_pipeline,
    package_path=PIPELINE_FILE,
)

    ב File Browser, מופיע קובץ בשם pipeline_config.yaml ברשימת הקבצים.

יצירת מאגר ב-Artifact Registry

  1. מריצים את הקוד הבא בתא חדש ב-Notebook כדי ליצור מאגר פריטי מידע מסוג KFP:

    REPO_NAME="fungi-repo"
REGION="us-central1"
!gcloud artifacts repositories create $REPO_NAME --location=$REGION --repository-format=KFP

העלאת תבנית צינור עיבוד הנתונים ל-Artifact Registry

בקטע הזה מגדירים לקוח של מרשם Kubeflow Pipelines SDK ומעלים את תבנית הצינור שעברה קומפילציה ל-Artifact Registry מ-JupyterLab notebook.

  1. ב-JupyterLab notebook, מריצים את הקוד הבא כדי להעלות את תבנית הצינור, ומחליפים את PROJECT_ID במזהה הפרויקט:

    PROJECT_ID = "PROJECT_ID"
from kfp.registry import RegistryClient
host = f"https://{REGION}-kfp.pkg.dev/{PROJECT_ID}/{REPO_NAME}"
client = RegistryClient(host=host)
TEMPLATE_NAME, VERSION_NAME = client.upload_pipeline(
   file_name=PIPELINE_FILE,
   tags=["v1", "latest"],
   extra_headers={"description":"This is an example pipeline template."})

  2. כדי לוודא שהתבנית הועלתה, נכנסים לדף Agent Platform Pipelines templates במסוף Google Cloud .

    כניסה לדף Pipelines

  3. כדי לפתוח את החלונית Select repository, לוחצים על Select repository.

  4. ברשימת המאגרים, לוחצים על המאגר שיצרתם (fungi-repo) ואז על Select.

  5. מוודאים שהצינור (custom-image-classification-pipeline) מופיע ברשימה.

הפעלת צינור עיבוד נתונים מקומית

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

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

  1. ב-JupyterLab notebook, מריצים את הפקודה הבאה כדי לאמת את שם התבנית של צינור עיבוד הנתונים:

    print (TEMPLATE_NAME)

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

    custom-image-classification-pipeline

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

    print (VERSION_NAME)

    השם של גרסת התבנית של צינור עיבוד הנתונים שמוחזרת נראה כך:

    sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7

    רושמים את כל המחרוזת של שם הגרסה.

  3. ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  4. מתחברים למכונה הווירטואלית on-prem-dataservice-host:

    gcloud compute ssh on-prem-dataservice-host \
    --zone=us-central1-a \
    --tunnel-through-iap

  5. במכונה הווירטואלית on-prem-dataservice-host, משתמשים בכלי לעריכת טקסט כמו vim או nano כדי ליצור את הקובץ request_body.json, לדוגמה:

    sudo vim request_body.json

  6. מוסיפים את הטקסט הבא לקובץ request_body.json:

    {
"displayName": "fungi-image-pipeline-job",
"serviceAccount": "onprem-user-managed-sa@PROJECT_ID.iam.gserviceaccount.com",
"runtimeConfig":{
"gcsOutputDirectory":"gs://pipelines-staging-bucket-PROJECT_ID/pipeline_root/",
"parameterValues": {
   "project": "PROJECT_ID",
   "training_job_display_name": "fungi-image-training-job",
   "worker_pool_specs": [{
      "machine_spec": {
         "machine_type": "n1-standard-4"
      },
      "replica_count": 1,
      "python_package_spec":{
         "executor_image_uri":"us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8.py310:latest",
         "package_uris": ["gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz"],
         "python_module": "trainer.task",
         "args": ["--data-dir","/mnt/nfs/fungi_dataset/", "--epochs", "10"],
         "env": [{"name": "AIP_MODEL_DIR", "value": "gs://pipelines-staging-bucket-PROJECT_ID/model/"}]
      },
      "nfs_mounts": [{
         "server": "FILESTORE_INSTANCE_IP",
         "path": "/vol1",
         "mount_point": "/mnt/nfs/"
      }]
   }],
   "base_output_dir":"gs://pipelines-staging-bucket-PROJECT_ID",
   "model_artifact_uri":"gs://pipelines-staging-bucket-PROJECT_ID/model/",
   "prediction_container_uri":"us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest",
   "model_display_name":"fungi-image-model",
   "endpoint_display_name":"fungi-image-endpoint",
   "location": "us-central1",
   "serving_machine_type":"n1-standard-4",
   "network":"projects/PROJECT_NUMBER/global/networks/vertex-networking-vpc"
     }
},
"templateUri": "https://us-central1-kfp.pkg.dev/PROJECT_ID/fungi-repo/custom-image-classification-pipeline/latest",
"templateMetadata": {
   "version":"VERSION_NAME"
}
}

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

    • ‫PROJECT_ID: מזהה הפרויקט
    • ‫PROJECT_NUMBER: מספר הפרויקט. זה שונה ממזהה הפרויקט. מספר הפרויקט מופיע בדף הגדרות הפרויקט של הפרויקט במסוףGoogle Cloud .
    • ‫FILESTORE_INSTANCE_IP: כתובת ה-IP של מכונת Filestore, לדוגמה 10.243.208.2. אפשר למצוא אותו בדף Filestore Instances של המכונה.
    • ‫VERSION_NAME: השם של גרסת התבנית של צינור עיבוד הנתונים (sha256:...) שרשמתם בשלב 2.

  7. שומרים את הקובץ באופן הבא:

    • אם אתם משתמשים ב-vim, לחצו על המקש Esc ואז הקלידו :wq כדי לשמור את הקובץ ולצאת.
    • אם אתם משתמשים ב-nano, מקלידים Control+O ולוחצים על Enter כדי לשמור את הקובץ, ואז מקלידים Control+X כדי לצאת.

שליחת הרצה של צינור עיבוד נתונים מהתבנית

  1. במכונה הווירטואלית on-prem-dataservice-host, מריצים את הפקודה הבאה, ומחליפים את PROJECT_ID במזהה הפרויקט:

    curl -v -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request_body.json \
https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/pipelineJobs

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

    "state": "PIPELINE_STATE_PENDING"

    הרצת הצינור כולו נמשכת כ-45 עד 50 דקות.

  2. במסוף Google Cloud , בקטע Gemini Enterprise Agent Platform, נכנסים לכרטיסייה Runs בדף Pipelines.

    מעבר אל Runs

  3. לוחצים על שם ההרצה של הצינור (custom-image-classification-pipeline).

    מופיע דף הרצת צינור עיבוד הנתונים ומוצג בו תרשים זמן הריצה של צינור עיבוד הנתונים. סיכום הצינור מופיע בחלונית Pipeline run analysis.

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

הסרת המשאבים

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

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

  1. מוחקים את כל הרצות הצינורות באופן הבא:

    1. במסוף Google Cloud , בקטע Gemini Enterprise Agent Platform, נכנסים לכרטיסייה Runs בדף Pipelines.

      מעבר אל Runs

    2. בוחרים את הרצות הצינור שרוצים למחוק ולוחצים על Delete.

  2. כדי למחוק את תבנית צינור עיבוד הנתונים:

    1. בקטע Gemini Enterprise Agent Platform, עוברים לכרטיסייה Your templates בדף Pipelines.

      כניסה לדף Pipelines

    2. ליד תבנית הצינור custom-image-classification-pipeline, לוחצים על Actions ובוחרים באפשרות Delete.

  3. מוחקים את המאגר מ-Artifact Registry באופן הבא:

    1. בדף Artifact Registry, נכנסים לכרטיסייה Repositories.

      כניסה לדף Repositories

    2. בוחרים את המאגר fungi-repo ולוחצים על Delete.

  4. מבטלים את פריסת המודל מנקודת הקצה באופן הבא:

    1. בקטע Gemini Enterprise Agent Platform, נכנסים לכרטיסייה Endpoints בדף Online predictions.

      כניסה לדף Endpoints

    2. לוחצים על fungi-image-endpoint כדי לעבור לדף הפרטים של נקודת הקצה.

    3. בשורה של המודל fungi-image-model, לוחצים על Actions ובוחרים באפשרות Undeploy model from endpoint.

    4. בתיבת הדו-שיח Undeploy model from endpoint, לוחצים על Undeploy.

  5. כדי למחוק את נקודת הקצה:

    1. בקטע Gemini Enterprise Agent Platform, נכנסים לכרטיסייה Endpoints בדף Online predictions.

      כניסה לדף Endpoints

    2. לוחצים על fungi-image-endpoint ואז על מחיקה.

  6. כדי למחוק את המודל:

    1. נכנסים לדף Model Registry.

      לדף Models

    2. בשורה של המודל fungi-image-model, לוחצים על Actions ובוחרים באפשרות Delete model.

  7. כדי למחוק את קטגוריית ה-Staging:

    1. נכנסים לדף Cloud Storage.

      כניסה ל-Cloud Storage

    2. בוחרים את pipelines-staging-bucket-PROJECT_ID, כאשר PROJECT_ID הוא מזהה הפרויקט, ולוחצים על Delete.

  8. כדי למחוק את המכונה של Agent Platform Workbench:

    1. בקטע Gemini Enterprise Agent Platform, נכנסים לכרטיסייה Instances בדף Workbench.

      כניסה ל-Agent Platform Workbench

    2. בוחרים את המכונה pipeline-tutorial-PROJECT_ID של Agent Platform Workbench, כאשר PROJECT_ID הוא מזהה הפרויקט, ולוחצים על Delete.

  9. כדי למחוק את המכונה הווירטואלית של Compute Engine:

    1. נכנסים לדף Compute Engine.

      כניסה ל-Compute Engine

    2. בוחרים את המכונה הווירטואלית on-prem-dataservice-host ולוחצים על Delete.

  10. מוחקים את מנהרות ה-VPN באופן הבא:

    1. נכנסים לדף VPN.

      מעבר אל VPN

    2. בדף VPN, לוחצים על הכרטיסייה Cloud VPN Tunnels.

    3. ברשימת מנהרות ה-VPN, בוחרים את ארבע המנהרות שיצרתם במדריך הזה ולוחצים על Delete.

  11. מוחקים את שערי ה-HA VPN באופן הבא:

    1. בדף VPN, לוחצים על הכרטיסייה Cloud VPN Gateways.

      כניסה לדף Cloud VPN Gateways

    2. ברשימת שערי ה-VPN, לוחצים על onprem-vpn-gw1.

    3. בדף Cloud VPN gateway details, לוחצים על Delete VPN Gateway.

    4. אם צריך, לוחצים על החץ חזרה כדי לחזור לרשימת שערי ה-VPN, ואז לוחצים על vertex-networking-vpn-gw1.

    5. בדף Cloud VPN gateway details, לוחצים על Delete VPN Gateway.

  12. כדי למחוק את נתבי Cloud Router:

    1. נכנסים לדף Cloud Routers.

      כניסה לדף Cloud Routers

    2. ברשימת הנתבים של Cloud Router, בוחרים את ארבעת הנתבים שיצרתם במדריך הזה.

    3. כדי למחוק את הנתבים, לוחצים על Delete.

      הפעולה הזו תמחק גם את שני שערי Cloud NAT שמחוברים ל-Cloud Routers.

  13. מוחקים את החיבורים של Service Networking לרשתות ה-VPC של vertex-networking-vpc ו-onprem-dataservice-vpc:

    1. נכנסים לדף VPC Network Peering.

      כניסה לדף VPC Network Peering

    2. בוחרים באפשרות servicenetworking-googleapis-com.

    3. כדי למחוק את החיבורים, לוחצים על Delete.

  14. מוחקים את כלל ההעברה pscvertex של רשת ה-VPC‏ vertex-networking-vpc באופן הבא:

    1. נכנסים לכרטיסייה Frontends בדף Load balancing.

      כניסה לדף Frontends

    2. ברשימת כללי ההעברה, לוחצים על pscvertex.

    3. בדף פרטי כלל העברה גלובלי, לוחצים על מחיקה.

  15. כדי למחוק את המכונה של Filestore:

    1. נכנסים לדף Filestore.

      כניסה ל-Filestore

    2. בוחרים את המכונה של image-data-instance.

    3. כדי למחוק את המכונה, לוחצים על Actions ואז על Delete instance.

  16. מוחקים את רשתות ה-VPC באופן הבא:

    1. נכנסים לדף VPC networks.

      כניסה לדף VPC networks

    2. ברשימת רשתות ה-VPC, לוחצים על onprem-dataservice-vpc.

    3. בדף פרטי רשת VPC, לוחצים על מחיקת רשת VPC.

      כשמוחקים כל רשת, נמחקים גם רשתות המשנה, הנתיבים וכללי חומת האש שלה.

    4. ברשימת רשתות ה-VPC, לוחצים על vertex-networking-vpc.

    5. בדף פרטי רשת VPC, לוחצים על מחיקת רשת VPC.

  17. מוחקים את חשבונות השירות workbench-sa ו-onprem-user-managed-sa באופן הבא:

    1. נכנסים לדף Service accounts.

      כניסה לדף Service accounts

    2. בוחרים את חשבונות השירות onprem-user-managed-sa ו-workbench-sa ולוחצים על Delete.

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