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

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

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

עלויות

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

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

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

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

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

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

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

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

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

    • Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
    • יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (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). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד 'אדמין בממשק Service Usage' (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, והשנייה כדי לדמות רשת מקומית. בכל אחת משתי רשתות ה-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 networks.

    מעבר לרשתות VPC

  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. השני נמצא ברשת onprem-dataservice-vpc VPC. כל שער מכיל Cloud Router וצמד מנהרות VPN.

יצירת שערי HA VPN

  1. יוצרים ב-Cloud Shell שער HA VPN לרשת vertex-networking-vpc 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: אחד לשימוש עם 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 לרשת onprem-dataservice-vpc 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 לרשת onprem-dataservice-vpc 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, לוחצים על cloud-router-us-central1-vertex-nat.

  10. בדף פרטי הנתב, מוודאים ששער cloud-nat-us-central1 Cloud NAT נוצר.

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

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

  13. בדף Router details (פרטי הנתב), מוודאים שנוצר שער cloud-nat-us-central1-on-premCloud NAT.

יצירת מנהרות 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 יוצרים יחד סשן 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

  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טווח כתובות ה-IP של תת-הרשת (172.16.10.0/24) מופיע פעמיים.

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

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

  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 של נקודת הקצה (endpoint) של PSC ברשת VPC‏ onprem-dataservice-vpc.

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

    מעבר אל Cloud Routers

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

  3. בדף פרטי הנתב, לוחצים על עריכה.

  4. בקטע מסלולים שפורסמו, בשורה מסלולים, בוחרים באפשרות יצירת מסלולים בהתאמה אישית.

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

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

  7. בשדה מקור, בוחרים באפשרות טווח כתובות IP בהתאמה אישית.

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

    192.168.0.1

  9. בקטע תיאור, מזינים את הטקסט הבא:

    Custom route to advertise Private Service Connect endpoint IP address

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

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

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

    לדף Routes

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

    1. בקטע רשת, בוחרים באפשרות onprem-dataservice-vpc.
    2. בשדה אזור, בוחרים באפשרות 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.

יצירת מכונת VM במופע ב-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. מקצים את התפקיד Gemini Enterprise Agent Platform Viewer (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 Reader (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. מקצים את התפקיד אדמין של אובייקטים באחסון (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. הקצאת התפקיד אדמין של יומני רישום (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 להתחבר למכונת ה-VM:

    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, מתחברים למכונת ה-VM מספר on-prem-dataservice-host באמצעות IAP:

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

  2. בon-prem-dataservice-host VM instance, משתמשים בכלי לעריכת טקסט כמו 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). כדי להבין מה עושים בקטע הזה ובקטע הבא, אפשר לעיין במאמרים Mount an NFS share for custom training וSet up VPC Network Peering.

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

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

  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. יוצרים קישור בין רשת ה-onprem-dataservice-vpcVPC לבין 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.

יצירת פרסום של מסלולים מותאמים אישית עבור filestore-subnet

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

    מעבר אל Cloud Routers

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

  3. בדף פרטי הנתב, לוחצים על עריכה.

  4. בקטע מסלולים שפורסמו, בשורה מסלולים, בוחרים באפשרות יצירת מסלולים בהתאמה אישית.

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

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

  7. בשדה מקור, בוחרים באפשרות טווח כתובות IP בהתאמה אישית.

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

    10.243.208.0/24

  9. בקטע תיאור, מזינים את הטקסט הבא:

    Filestore reserved IP address range

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

יוצרים את מופע Filestore ברשת onprem-dataservice-vpc

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

יצירת מכונת Filestore

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

    כניסה לדף Filestore Instances

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

    • מגדירים את Instance ID (מזהה המופע) לערך הבא:

      image-data-instance

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

    • מגדירים את סוג האחסון ל-HDD.

    • מגדירים את הקצאת קיבולת ל-1 TiB.

    • בשדה Region בוחרים באפשרות us-central1, ובשדה Zone בוחרים באפשרות us-central1-c.

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

    • מגדירים את טווח כתובות ה-IP שהוקצה לשימוש בטווח כתובות IP שהוקצה ובוחרים באפשרות 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-hostVM:

    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. מבצעים Mount לשיתוף הקבצים, ומחליפים את 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 מאחסנים את הארטיפקטים של הרצות צינורות עיבוד הנתונים באמצעות Cloud Storage. לפני שמריצים את צינור העיבוד, צריך ליצור קטגוריה של Cloud Storage להעברת ריצות של צינור העיבוד.

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

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

    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. במסוף Google Cloud , עוברים לכרטיסייה Instances בדף Vertex AI Workbench.

    כניסה לדף Agent Platform Workbench

  2. לוחצים על  יצירת חדש ואז על אפשרויות מתקדמות.

    הדף New instance (מופע חדש) ייפתח.

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

    • שם: מזינים את הערך הבא ומחליפים את PROJECT_ID במזהה הפרויקט:

      pipeline-tutorial-PROJECT_ID

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

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

    • מבטלים את הסימון בתיבת הסימון הפעלת סשנים אינטראקטיביים של Dataproc Serverless.

  4. בקטע סביבה, לוחצים על המשך.

  5. בקטע Machine type (סוג המכונה), מציינים את הפרטים הבאים ולוחצים על Continue (המשך):

    • Machine type (סוג המכונה): בוחרים באפשרות N1 ואז באפשרות n1-standard-4 בתפריט Machine type.

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

      • אתחול מאובטח
      • מודול וירטואלי של Trusted Platform (vTPM)
      • מעקב אחר תקינות

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

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

    • רשת: בוחרים באפשרות רשת בפרויקט הזה ופועלים לפי השלבים הבאים:

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

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

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

      4. מסמנים את תיבת הסימון Allow proxy access (מתן גישה לשרת proxy).

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

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

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

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

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com

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

        מידע נוסף על מתן גישה מופיע במאמר בנושא ניהול הגישה לממשק JupyterLab של מופע Agent Platform Workbench.

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

      • גישת רוט למופע

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

      • ‫nbconvert: nbconvert מאפשר למשתמשים לייצא ולהוריד קובץ notebook כסוג קובץ אחר, כמו HTML,‏ PDF או LaTeX. ההגדרה הזו נדרשת בחלק מקובצי ה-notebook במאגר Google Cloud Generative AI ב-GitHub.

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

      • הורדת קובץ

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

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

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

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

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

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

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

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

    כניסה לדף Agent Platform Workbench

  2. לצד השם של מופע Agent Platform Workbench ‏(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. ב File Browser, לוחצים לחיצה כפולה על התיקייה fungi_training_package.

  15. בוחרים באפשרות קובץ > חדש > קובץ 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 לקטגוריית האחסון הזמני:

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

  26. מוודאים שמאגר הביניים מכיל את החבילה:

    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 שמשמש להגדרת שירותים של ספק שמחוברים לרשת ה-VPC‏ vertex-networking-vpc באמצעות קישור בין רשתות VPC שכנות (peering). מידע נוסף זמין במאמר VPC Network Peering.

  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. יוצרים קישור בין רשת ה-vertex-networking-vpcVPC לבין 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. בדף פרטי הנתב, לוחצים על עריכה.

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

  5. בשדה מקור, בוחרים באפשרות טווח כתובות IP בהתאמה אישית.

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

    192.168.10.0/24

  7. בקטע תיאור, מזינים את הטקסט הבא:

    Agent Platform Pipelines reserved subnet

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

יצירת תבנית של פייפליין והעלאה שלה ל-Artifact Registry

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

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

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

  2. בוחרים באפשרות קובץ > חדש > מחברת.

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

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

    !python -m pip install --upgrade pip

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

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

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

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

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

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

יצירת מאגר Artifact Registry

  1. מריצים את הקוד הבא בתא חדש של נוטבוק כדי ליצור מאגר ארטיפקטים מסוג 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.

  1. במחברת JupyterLab, מריצים את הקוד הבא כדי להעלות את תבנית הצינור, ומחליפים את 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. כדי לוודא שהתבנית הועלתה במסוף Google Cloud , עוברים אל Agent Platform Pipelines templates.

    מעבר אל Pipelines

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

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

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

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

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

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

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

    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-hostVM:

    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. במכונת ה-VM‏ 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. בוחרים את ההרצות של צינורות הנתונים שרוצים למחוק ולוחצים על מחיקה.

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

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

      מעבר אל Pipelines

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

  3. כדי למחוק את המאגר מ-Artifact Registry:

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

      כניסה לדף Repositories

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

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

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

      לדף Endpoints

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

    3. בשורת המודל, fungi-image-model, לוחצים על פעולות ובוחרים באפשרות ביטול הפריסה של המודל מנקודת הקצה.

    4. בתיבת הדו-שיח Undeploy model from endpoint (ביטול הפריסה של המודל מנקודת הקצה), לוחצים על Undeploy (ביטול הפריסה).

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

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

      לדף Endpoints

    2. בוחרים באפשרות fungi-image-endpoint ולוחצים על מחיקה.

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

    1. עוברים לדף מרשם המודלים.

      מעבר אל 'מודלים'

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

  7. כדי למחוק את קטגוריית הביניים:

    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_IDAgent Platform Workbench, כאשר PROJECT_ID הוא מזהה הפרויקט, ולוחצים על מחיקה.

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

    1. עוברים לדף Compute Engine.

      מעבר אל Compute Engine

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

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

    1. עוברים לדף VPN.

      מעבר אל VPN

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

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

  11. כדי למחוק את שערי ה-HA VPN:

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

      מעבר אל Cloud VPN Gateways

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

    3. בדף Cloud VPN gateway details (פרטי שער Cloud VPN), לוחצים על Delete VPN Gateway (מחיקת שער VPN).

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

    5. בדף Cloud VPN gateway details (פרטי שער Cloud VPN), לוחצים על Delete VPN Gateway (מחיקת שער VPN).

  12. כדי למחוק את Cloud Routers:

    1. עוברים לדף Cloud Routers.

      מעבר אל Cloud Routers

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

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

      הפעולה הזו תמחק גם את שני שערי 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. כדי למחוק את הקישורים, לוחצים על מחיקה.

  14. כדי למחוק את כלל ההעברה pscvertex של רשת ה-VPCvertex-networking-vpc, פועלים לפי השלבים הבאים:

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

      כניסה לדף Frontends

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

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

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

    1. עוברים לדף Filestore.

      מעבר אל Filestore

    2. בוחרים את המופע image-data-instance.

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

  16. כדי למחוק את רשתות ה-VPC:

    1. עוברים לדף VPC networks.

      מעבר לרשתות VPC

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

    3. בדף VPC network details (פרטי רשת VPC), לוחצים על Delete VPC Network (מחיקת רשת VPC).

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

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

    5. בדף VPC network details (פרטי רשת VPC), לוחצים על Delete VPC Network (מחיקת רשת VPC).

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

    1. עוברים לדף Service accounts.

      כניסה לדף Service accounts

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

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