‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

שימוש ב-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) מיועד לשימוש בממשק ה-API של Agent Platform Pipelines כדי ליצור תבנית של צינור עיבוד נתונים ולארח אותה לצורך אימון מודל למידת מכונה ופריסתו בנקודת קצה.
- האפשרות השנייה (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 ? יכול להיות שאתם זכאים לתקופת ניסיון בחינם.

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

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

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

כניסה לדף לבחירת הפרויקט
בוחרים או יוצרים Google Cloud פרויקט.
תפקידים שנדרשים כדי לבחור או ליצור פרויקט
- Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
- יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (יצירת פרויקטים) (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים
מוודאים שהחיוב מופעל בפרויקט Google Cloud .
פותחים את Cloud Shell כדי להריץ את הפקודות שמפורטות במדריך הזה. ‫Cloud Shell היא סביבת מעטפת אינטראקטיבית של Google Cloud שמאפשרת לכם לנהל את הפרויקטים והמשאבים שלכם מדפדפן האינטרנט.
ב-Cloud Shell, מגדירים את הפרויקט הנוכחי למזהה הפרויקט Google Cloud ומאחסנים את אותו מזהה פרויקט במשתנה המעטפת projectid:
‫
```
  projectid="PROJECT_ID"
  gcloud config set project ${projectid}
```
מחליפים את PROJECT_ID במזהה הפרויקט. במקרה הצורך, אפשר לאתר את מזהה הפרויקט במסוף Google Cloud . מידע נוסף זמין במאמר איך מאתרים את מזהה הפרויקט.
אם אתם לא הבעלים של הפרויקט, אתם צריכים לבקש מהבעלים של הפרויקט להקצות לכם את התפקיד אדמין IAM בפרויקט (roles/resourcemanager.projectIamAdmin). כדי להקצות תפקידי IAM בשלב הבא, צריך להיות לכם התפקיד הזה.
מעניקים תפקידים לחשבון המשתמש. מריצים את הפקודה הבאה לכל אחד מהתפקידים הבאים ב-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 שאתם מקצים לחשבון המשתמש.
מפעילים את ממשקי ה-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 חיצוניות.

ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

יוצרים את רשת ה-VPC‏ vertex-networking-vpc:

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

ברשת 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

יוצרים את רשת ה-VPC כדי לדמות את הרשת המקומית (onprem-dataservice-vpc):
```
gcloud compute networks create onprem-dataservice-vpc \
    --subnet-mode custom
```

ברשת 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 נכונות

במסוף Google Cloud , עוברים לכרטיסייה Networks in current project בדף VPC networks.

מעבר לרשתות VPC
ברשימת רשתות ה-VPC, מוודאים ששתי הרשתות נוצרו: vertex-networking-vpc ו-onprem-dataservice-vpc.
לוחצים על הכרטיסייה Subnets in current project (רשתות משנה בפרויקט הנוכחי).
ברשימת רשתות המשנה של ה-VPC, מוודאים שרשתות המשנה pipeline-networking-subnet1 ו-onprem-dataservice-vpc-subnet1 נוצרו.

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

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

יצירת שערי HA VPN

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

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

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

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

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

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

יצירה של Cloud Routers ושערי Cloud NAT

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

יוצרים ב-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

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

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

יוצרים 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

מגדירים שער 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

יוצרים 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

מגדירים שער 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

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

מעבר אל Cloud Routers
ברשימה Cloud Routers, מוודאים שהנתבים הבאים נוצרו:
- cloud-router-us-central1-onprem-nat
- cloud-router-us-central1-vertex-nat
- onprem-dataservice-vpc-router1
- vertex-networking-vpc-router1
יכול להיות שתצטרכו לרענן את הכרטיסייה בדפדפן של Google Cloud מסוף כדי לראות את הערכים החדשים.
ברשימת נתבי Cloud, לוחצים על cloud-router-us-central1-vertex-nat.
בדף פרטי הנתב, מוודאים ששער Cloud NAT נוצר.cloud-nat-us-central1
לוחצים על החץ חזרה כדי לחזור לדף Cloud Routers.
ברשימת נתבי Cloud, לוחצים על cloud-router-us-central1-onprem-nat.
בדף פרטי הנתב, מוודאים שנוצר שער cloud-nat-us-central1-on-prem Cloud NAT.

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

ב-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

ברשת 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

ברשת 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

ברשת 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

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

מעבר אל VPN
ברשימת מנהרות ה-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`

ב-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

ברשת 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

ברשת 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

ברשת 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`

ברשת 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

ברשת 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

ברשת 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

ברשת 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

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

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

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

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

מעבר לרשתות VPC
ברשימת רשתות ה-VPC, לוחצים על onprem-dataservice-vpc.
לוחצים על הכרטיסייה מסלולים.
בוחרים באפשרות us-central1 (Iowa) ברשימה Region ולוחצים על View.
בעמודה Destination IP range מוודאים שטווח כתובות ה-IP של רשת המשנה pipeline-networking-subnet1 (10.0.0.0/24) מופיע פעמיים.

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

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

לוחצים על החץ חזרה כדי לחזור לדף רשתות VPC.
ברשימת רשתות ה-VPC, לוחצים על vertex-networking-vpc.
לוחצים על הכרטיסייה מסלולים.
בוחרים באפשרות us-central1 (Iowa) ברשימה Region ולוחצים על View.
בעמודה Destination IP range (טווח כתובות ה-IP של היעד), מוודאים שטווח כתובות ה-IP של רשת המשנה (172.16.10.0/24) מופיע פעמיים.onprem-dataservice-vpc-subnet1

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

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

ב-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

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

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

מעבר אל Cloud Routers
ברשימת Cloud Router, לוחצים על vertex-networking-vpc-router1.
בדף פרטי הנתב, לוחצים על עריכה.
בקטע מסלולים שפורסמו, בשורה מסלולים, בוחרים באפשרות יצירת מסלולים בהתאמה אישית.
מסמנים את התיבה Advertise all subnets visible to the Cloud Router כדי להמשיך לפרסם את רשתות המשנה שזמינות ל-Cloud Router. הפעלת האפשרות הזו מדמה את ההתנהגות של Cloud Router במצב ברירת המחדל של פרסום.
לוחצים על הוספת נתיב בהתאמה אישית.
בשדה מקור, בוחרים באפשרות טווח כתובות IP בהתאמה אישית.
בשדה טווח כתובות IP, מזינים את כתובת ה-IP הבאה:
```
192.168.0.1
```

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

Custom route to advertise Private Service Connect endpoint IP address

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

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

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

לדף Routes
בכרטיסייה 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.

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

ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

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

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

מקצים לחשבון השירות את התפקיד 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"

מקצים את התפקיד 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"

הקצאת התפקיד עריכת 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"

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

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

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

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

הקצאת התפקיד Artifact Registry Reader (קורא של 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"

הקצאת התפקיד אדמין של אובייקט אחסון (roles/storage.objectAdmin):

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

הקצאת התפקיד אדמין של יומני רישום (roles/logging.admin):

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

יצירת מופע של מכונה וירטואלית `on-prem-dataservice-host`

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

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

יוצרים כלל חומת אש שמאפשר ל-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).

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

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

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

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

192.168.0.1 us-central1-aiplatform.googleapis.com

בשורה הזו מוקצית כתובת ה-IP של נקודת הקצה (endpoint) של PSC ‏(192.168.0.1) לשם דומיין שמוגדר במלואו עבור Google API של Gemini Enterprise Agent Platform ‏(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

שומרים את הקובץ באופן הבא:
- אם אתם משתמשים ב-vim, לוחצים על המקש Esc, ואז מקלידים :wq כדי לשמור את הקובץ ולצאת.
- אם אתם משתמשים ב-nano, מקלידים Control+O ומקישים על Enter כדי לשמור את הקובץ, ואז מקלידים Control+X כדי לצאת.
מבצעים פינג לנקודת קצה ל-API של Agent Platform באופן הבא:
```
ping us-central1-aiplatform.googleapis.com
```
הפלט הבא אמור להתקבל באמצעות הפקודה ping. ‫192.168.0.1 היא כתובת ה-IP של נקודת הקצה (endpoint) של PSC:
```
PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.
```
מקלידים Control+C כדי לצאת מ-ping.
מקלידים exit כדי לצאת ממכונת ה-VM on-prem-dataservice-host ולחזור להנחיה של Cloud Shell.

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

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

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

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

ב-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

יוצרים קישור בין רשת ה-VPC לבין Service Networking של Google באמצעות gcloud services vpc-peerings connect:onprem-dataservice-vpc

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

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

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

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

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

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

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

מעבר אל Cloud Routers
ברשימת Cloud Router, לוחצים על onprem-dataservice-vpc-router1.
בדף פרטי הנתב, לוחצים על עריכה.
בקטע מסלולים שפורסמו, בשורה מסלולים, בוחרים באפשרות יצירת מסלולים בהתאמה אישית.
מסמנים את התיבה Advertise all subnets visible to the Cloud Router כדי להמשיך לפרסם את רשתות המשנה שזמינות ל-Cloud Router. הפעלת האפשרות הזו מדמה את ההתנהגות של Cloud Router במצב ברירת המחדל של פרסום.
לוחצים על הוספת נתיב בהתאמה אישית.
בשדה מקור, בוחרים באפשרות טווח כתובות IP בהתאמה אישית.
בשדה IP address range (טווח כתובות IP), מזינים את טווח כתובות ה-IP הבא:
```
10.243.208.0/24
```
בקטע תיאור, מזינים את הטקסט הבא:
```
Filestore reserved IP address range
```
לוחצים על סיום ואז על שמירה.

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

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

יצירת מופע Filestore

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

כניסה לדף Filestore Instances
לוחצים על Create instance ומגדירים את המכונה באופן הבא:
- מגדירים את מזהה המופע באופן הבא:
```
image-data-instance
```
- מגדירים את Instance type בתור Basic.
- מגדירים את סוג האחסון ל-HDD.
- מגדירים את האפשרות הקצאת קיבולת ל-1 TiB.
- מגדירים את Region ל-us-central1 ואת Zone ל-us-central1-c.
- מגדירים את רשת ה-VPC ל-onprem-dataservice-vpc.
- מגדירים את Allocated IP range (טווח כתובות IP שהוקצה) לאפשרות Use an existing allocated IP range (שימוש בטווח כתובות IP שהוקצה) ובוחרים באפשרות filestore-subnet.
- מגדירים את File share name (שם שיתוף הקבצים) באופן הבא:
```
vol1
```
- מגדירים את בקרת הגישה להענקת גישה לכל הלקוחות ברשת ה-VPC.
לוחצים על יצירה.
חשוב לשים לב לכתובת ה-IP של מופע Filestore החדש. יכול להיות שתצטרכו לרענן את כרטיסיית הדפדפן של Google Cloud המסוף כדי לראות את המכונה החדשה.

טעינת התקן רשת לשיתוף קבצים ב-Filestore

ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

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

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

מתקינים את חבילת NFS במכונה הווירטואלית:
```
sudo apt-get update -y
sudo apt-get -y install nfs-common
```
יוצרים ספריית טעינה לשיתוף הקבצים ב-Filestore:
```
sudo mkdir -p /mnt/nfs
```
הערה: חשוב לוודא ששם התיקייה של נקודת הטעינה בתוך /mnt/ הוא nfs. הסיבה לכך היא ששיתוף הקבצים ב-NFS מותקן בתיקייה /mnt/nfs/ בתוך משימת האימון בהתאמה אישית.
מטעינים את שיתוף הקבצים, ומחליפים את FILESTORE_INSTANCE_IP בכתובת ה-IP של מופע Filestore:
```
sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
```
אם החיבור נכשל בגלל פסק זמן, צריך לוודא שציינתם את כתובת ה-IP הנכונה של מופע Filestore.

מריצים את הפקודה הבאה כדי לוודא שהרכבת ה-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

כדי לשנות את ההרשאות ולתת גישה לשיתוף הקבצים:
```
sudo chmod go+rw /mnt/nfs
```
הערה: בסביבת ייצור, מומלץ להגדיר הרשאות מפורטות יותר. מידע נוסף זמין במאמר בנושא הגדרת גישה לשיתוף קבצים.

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

במכונה הווירטואלית on-prem-dataservice-host, מורידים את מערך הנתונים אל שיתוף הקבצים:
```
gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
```
ההורדה נמשכת כמה דקות.
כדי לוודא שהעתקת מערך הנתונים בוצעה בהצלחה, מריצים את הפקודה הבאה:
```
sudo du -sh /mnt/nfs
```
הפלט הצפוי:
```
104M    /mnt/nfs
```
מקלידים exit כדי לצאת ממכונת ה-VM on-prem-dataservice-host ולחזור להנחיה של Cloud Shell.

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

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

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

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

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

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

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

מקצים לחשבון השירות את התפקיד 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"

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

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

הקצאת התפקיד 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

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

כניסה לדף Agent Platform Workbench
לוחצים על יצירת ערוץ חדש ואז על אפשרויות מתקדמות.

הדף New instance (מופע חדש) ייפתח.
בדף New instance (מופע חדש), בקטע Details (פרטים), מספקים את הפרטים הבאים לגבי המופע החדש ולוחצים על Continue (המשך):
- שם: מזינים את הערך הבא ומחליפים את PROJECT_ID במזהה הפרויקט:
```
pipeline-tutorial-PROJECT_ID
```
- אזור: בוחרים באפשרות us-central1.
- תחום: בוחרים באפשרות us-central1-a.
- מבטלים את הסימון בתיבת הסימון הפעלת סשנים אינטראקטיביים של Dataproc Serverless.
בקטע סביבה, לוחצים על המשך.
בקטע Machine type (סוג המכונה), מציינים את הפרטים הבאים ולוחצים על Continue (המשך):
- סוג המכונה: בוחרים באפשרות N1 ואז בוחרים באפשרות n1-standard-4 בתפריט סוג המכונה.
- מכונה וירטואלית מוגנת: מסמנים את תיבות הסימון הבאות:
  - הפעלה מאובטחת
  - מודול וירטואלי Trusted Platform (vTPM)
  - מעקב אחר יושרה
בקטע Disks (דיסקים), מוודאים שהאפשרות Google-managed encryption key מסומנת, ואז לוחצים על Continue (המשך):
בקטע Networking (רשת), מזינים את הפרטים הבאים ולוחצים על Continue (המשך):
- רשתות: בוחרים באפשרות רשת בפרויקט הזה ומבצעים את השלבים הבאים:
  1. בשדה Network, בוחרים באפשרות vertex-networking-vpc.
  2. בשדה Subnetwork, בוחרים באפשרות pipeline-networking-subnet1.
  3. מבטלים את הסימון של התיבה הקצאת כתובת IP חיצונית. אם לא מקצים כתובת IP חיצונית, המופע לא יכול לקבל תקשורת לא רצויה מהאינטרנט או מרשתות VPC אחרות.
  4. מסמנים את תיבת הסימון Allow proxy access (מתן גישה לשרת proxy).
בקטע 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.
בקטע System health, מבטלים את הסימון של Environment auto-upgrade ומזינים את הפרטים הבאים:
- בקטע דיווח, מסמנים את תיבות הסימון הבאות:
  - דיווח על תקינות המערכת
  - דיווח על מדדים מותאמים אישית ל-Cloud Monitoring
  - התקנת Cloud Monitoring
  - דיווח על סטטוס ה-DNS עבור דומיינים נדרשים של Google
לוחצים על יצירה ומחכים כמה דקות עד שמופע של Agent Platform Workbench ייווצר.

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

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

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

המופע של Agent Platform Workbench ייפתח ב-JupyterLab.
בוחרים באפשרות קובץ > חדש > מסוף.
בטרמינל של JupyterLab (לא ב-Cloud Shell), מגדירים משתנה סביבה לפרויקט. מחליפים את PROJECT_ID במזהה הפרויקט:
```
projectid=PROJECT_ID
```
יוצרים את ספריות האב של אפליקציית האימון (עדיין בטרמינל של JupyterLab):
```
mkdir fungi_training_package
mkdir fungi_training_package/trainer
```
ב File Browser, לוחצים לחיצה כפולה על התיקייה fungi_training_package ואז לוחצים לחיצה כפולה על התיקייה trainer.
ב סייר הקבצים, לוחצים לחיצה ימנית על רשימת הקבצים הריקה (בקטע שם) ובוחרים באפשרות קובץ חדש.
לוחצים לחיצה ימנית על הקובץ החדש ובוחרים באפשרות שינוי שם הקובץ.
משנים את שם הקובץ מ-untitled.txt ל-task.py.
לוחצים לחיצה כפולה על הקובץ task.py כדי לפתוח אותו.

מעתיקים את הקוד הבא אל 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)

בוחרים באפשרות קובץ > שמירת קובץ Python.
בטרמינל של JupyterLab, יוצרים קובץ __init__.py בכל תיקיית משנה כדי להפוך אותה לחבילה:
```
touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py
```
ב סייר הקבצים, לוחצים לחיצה כפולה על התיקייה fungi_training_package.
בוחרים באפשרות קובץ > חדש > קובץ Python.
לוחצים לחיצה ימנית על הקובץ החדש ובוחרים באפשרות שינוי שם הקובץ.
משנים את שם הקובץ מ-untitled.py ל-setup.py.
לוחצים לחיצה כפולה על הקובץ setup.py כדי לפתוח אותו.

מעתיקים את הקוד הבא אל 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.'
)

בוחרים באפשרות קובץ > שמירת קובץ Python.
בטרמינל, עוברים לספרייה fungi_training_package:
```
cd fungi_training_package
```
משתמשים בפקודה sdist כדי ליצור את הפצת המקור של אפליקציית האימון:
```
python setup.py sdist --formats=gztar
```
מנווטים לספריית האב:
```
cd ..
```
מוודאים שאתם נמצאים בספרייה הנכונה:
```
pwd
```
הפלט אמור להיראות כך:
```
/home/jupyter
```

מעתיקים את חבילת Python לקטגוריית האחסון הזמני:

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

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

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.

ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

מגדירים טווח של כתובות 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

יוצרים קישור בין רשת ה-VPC לבין Service Networking של Google באמצעות gcloud services vpc-peerings connect:vertex-networking-vpc

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

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

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

פרסום רשת משנה של צינור מ-Cloud Router‏ `pipeline-networking`

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

מעבר אל Cloud Routers
ברשימת Cloud Router, לוחצים על vertex-networking-vpc-router1.
בדף פרטי הנתב, לוחצים על עריכה.
לוחצים על הוספת נתיב בהתאמה אישית.
בשדה מקור, בוחרים באפשרות טווח כתובות IP בהתאמה אישית.
בשדה IP address range (טווח כתובות IP), מזינים את טווח כתובות ה-IP הבא:
```
192.168.10.0/24
```
בקטע תיאור, מזינים את הטקסט הבא:
```
Agent Platform Pipelines reserved subnet
```
לוחצים על סיום ואז על שמירה.

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

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

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

ב-Jupyterlab, בחלונית File Browser, לוחצים לחיצה כפולה על התיקייה ברמה העליונה.
בוחרים באפשרות קובץ > חדש > מחברת.
בתפריט Select Kernel (בחירת ליבה), בוחרים באפשרות Python 3 (ipykernel) ולוחצים על Select (בחירה).
בתא חדש במחברת, מריצים את הפקודה הבאה כדי לוודא שיש לכם את הגרסה העדכנית של pip:
```
!python -m pip install --upgrade pip
```
מריצים את הפקודה הבאה כדי להתקין את Pipeline Components SDK מאינדקס החבילות של Python ‏ (PyPI): Google Cloud
```
!pip install --upgrade google-cloud-pipeline-components
```
אחרי שההתקנה מסתיימת, בוחרים באפשרות Kernel > Restart kernel (ליבה > הפעלה מחדש של הליבה) כדי להפעיל מחדש את הליבה ולוודא שהספרייה זמינה לייבוא.

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

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

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

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

במחברת 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."})

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

מעבר אל Pipelines
כדי לפתוח את החלונית Select repository (בחירת מאגר), לוחצים על Select repository (בחירת מאגר).
ברשימת המאגרים, לוחצים על המאגר שיצרתם (fungi-repo) ואז על Select.
מוודאים שצינור הנתונים (custom-image-classification-pipeline) מופיע ברשימה.

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

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

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

ב-notebook של JupyterLab, מריצים את הפקודה הבאה כדי לאמת את שם תבנית צינור עיבוד הנתונים:
```
print (TEMPLATE_NAME)
```
שם התבנית שמוחזר הוא:
```
custom-image-classification-pipeline
```
מריצים את הפקודה הבאה כדי לקבל את הגרסה של תבנית הצינור:
```
print (VERSION_NAME)
```
שם הגרסה של תבנית הצינור שמוחזרת נראה כך:
```
sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
```
מציינים את המחרוזת המלאה של שם הגרסה.
ב-Cloud Shell, מריצים את הפקודות הבאות ומחליפים את PROJECT_ID במזהה הפרויקט:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```