ממשק PSC של Vertex AI Pipelines Explicit Proxy

1. מבוא

ממשק Private Service Connect הוא משאב שמאפשר לרשת של ענן וירטואלי פרטי (VPC) של בעל שירות ליזום חיבורים ליעדים שונים ברשת VPC של צרכן. רשתות של יצרנים וצרכנים יכולות להיות בפרויקטים ובארגונים שונים.

אם קובץ מצורף עם הרשת מקבל חיבור מממשק Private Service Connect, מערכת Google Cloud מקצה לממשק כתובת IP מרשת משנה של צרכן שצוינה על ידי הקובץ המצורף עם הרשת. הרשתות של הצרכנים והיצרנים מחוברות ויכולות לתקשר באמצעות כתובות IP פנימיות.

חיבור בין קובץ מצורף עם הרשת לבין ממשק Private Service Connect דומה לחיבור בין נקודת קצה של Private Service Connect לבין קובץ מצורף עם השירות, אבל יש שני הבדלים עיקריים:

צירוף רשת מאפשר לרשת של ספק ליזום חיבורים לרשת של צרכן (תעבורת נתונים יוצאת (egress) של שירות מנוהל), ואילו נקודת קצה (endpoint) מאפשרת לרשת של צרכן ליזום חיבורים לרשת של ספק (תעבורת נתונים נכנסת (ingress) של שירות מנוהל).
חיבור ממשק Private Service Connect הוא טרנזיטיבי. המשמעות היא שרשת יצרן יכולה לתקשר עם רשתות אחרות שמחוברות לרשת הצרכן.

שיקולים לגבי נגישות של Vertex AI PSC-Interface

ממשק PSC יכול לנתב תנועה ליעדים מבוססי VPC או מקומיים בתוך בלוק הכתובות RFC1918.
טירגוט של בלוקים של כתובות שאינן rfc-1918 באמצעות PSC-Interface מחייב פריסה של שרת proxy מפורש ב-VPC של הלקוח עם כתובת rfc-1918. בפריסת Vertex AI, צריך להגדיר את ה-proxy יחד עם שם דומיין מלא (FQDN) של נקודת הקצה של היעד. באיור 1 מוצג פרוקסי מפורש שהוגדר ברשתות ה-VPC של הלקוחות כדי לאפשר ניתוב ל-CIDR הבאים שאינם rfc-1918:

‫[1] 240.0.0.0/4

‫[2] 203.0.113.0/2

‫[3]10.10.20.0/28 לא נדרש פרוקסי, נמצא בטווח rfc1918.

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

שיקולים לגבי Vertex AI PSC-Interface VPC-SC

כשהפרויקט שלכם הוא חלק ממערך של VPC Service Controls, הגישה לאינטרנט של הדיירים שמנוהלים על ידי Google נחסמת כברירת מחדל על ידי המערך כדי למנוע זליגת נתונים.
כדי לאפשר לפריסה גישה לאינטרנט הציבורי בתרחיש הזה, צריך להגדיר במפורש נתיב יציאה מאובטח שמעביר את התנועה דרך ה-VPC. הדרך המומלצת לעשות זאת היא להגדיר שרת proxy בתוך גבולות גזרת ה-VPC עם כתובת RFC1918 וליצור שער Cloud NAT כדי לאפשר למכונת ה-proxy הווירטואלית לגשת לאינטרנט.

למידע נוסף, אפשר לעיין במקורות המידע הבאים:

הגדרת ממשק Private Service Connect למשאבי Vertex AI | Google Cloud

מה תפַתחו

במדריך הזה, תיצרו פריסה מקיפה של Vertex AI Pipelines עם ממשק Private Service Connect ‏ (PSC) כדי לאפשר קישוריות מהיצרן למחשוב של הצרכן, כפי שמוצג באיור 1, שמכוונת לנקודות קצה שאינן rfc-1928.

איור 2

תיצרו קובץ יחיד של psc-network-attachment ב-VPC של הצרכן, ותשתמשו בקישור DNS כדי לפתור את בעיות המכונות הווירטואליות של הצרכן בפרויקט הדייר שמארח את Vertex AI Training. כך תוכלו להשתמש בתרחישי השימוש הבאים:

פריסת Vertex AI Pipelines והגדרת מכונת proxy וירטואלית שתפעל כ-proxy מפורש, כדי לאפשר לה לבצע wget מול מכונה וירטואלית ברשת המשנה Class E.

מה תלמדו

איך יוצרים קובץ מצורף לרשת
איך מפיק יכול להשתמש בקובץ מצורף לרשת כדי ליצור ממשק PSC
איך יוצרים תקשורת מהמפיק לצרכן באמצעות קישור בין רשתות שכנות (peering) של DNS
איך יוצרים תקשורת מ-Vertex AI Pipelines למרחב כתובות IP שאינו rfc1918

מה תצטרכו

פרויקט ב-Google Cloud

הרשאות IAM

אדמין של רשת מחשוב (roles/compute.networkAdmin)
אדמין מכונות של Compute (roles/compute.instanceAdmin)
אדמין לענייני אבטחה ב-Compute (roles/compute.securityAdmin)
אדמין DNS (roles/dns.admin)
משתמש מנהרה באבטחת IAP (roles/iap.tunnelResourceAccessor)
אדמין לניהול יומנים (roles/logging.admin)
אדמין של Notebooks (roles/notebooks.admin)
אדמין IAM בפרויקט (roles/resourcemanager.projectIamAdmin)
אדמין בחשבון שירות (roles/iam.serviceAccountAdmin)
אדמין של שימוש בשירות (roles/serviceusage.serviceUsageAdmin)

‫2. לפני שמתחילים

עדכון הפרויקט כדי לתמוך במדריך

במדריך הזה נעשה שימוש ב-$variables כדי לעזור בהטמעה של הגדרות gcloud ב-Cloud Shell.

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

הפעלת API

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud services enable "compute.googleapis.com"
gcloud services enable "aiplatform.googleapis.com"
gcloud services enable "dns.googleapis.com"
gcloud services enable "notebooks.googleapis.com"
gcloud services enable "storage.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"
gcloud services enable "artifactregistry.googleapis.com"
gcloud services enable "cloudbuild.googleapis.com"

3. הגדרת צרכן

יצירת VPC של צרכן

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud compute networks create consumer-vpc --project=$projectid --subnet-mode=custom

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

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud compute networks subnets create class-e-subnet --project=$projectid --range=240.0.0.0/4 --network=consumer-vpc --region=us-central1

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud compute networks subnets create rfc1918-subnet1 --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1

יצירת תת-רשת של צירוף רשת של Private Service Connect

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud compute networks subnets create intf-subnet --project=$projectid --range=192.168.10.0/28 --network=consumer-vpc --region=us-central1

הגדרת Cloud Router ו-NAT

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

ב-Cloud Shell, יוצרים את Cloud Router.

gcloud compute routers create cloud-router-for-nat --network consumer-vpc --region us-central1

ב-Cloud Shell, יוצרים את שער ה-NAT.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-for-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1 --enable-logging --log-filter=ALL

4. הפעלת IAP

כדי לאפשר ל-IAP להתחבר למכונות הווירטואליות, צריך ליצור כלל חומת אש ש:

רלוונטי לכל מכונות ה-VM שרוצים לגשת אליהן באמצעות IAP.
מאפשר תנועה נכנסת מטווח כתובות ה-IP‏ 35.235.240.0/20. הטווח הזה מכיל את כל כתובות ה-IP שמשמשות את IAP להעברת TCP.

ב-Cloud Shell, יוצרים את הכלל בחומת האש של IAP.

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

5. יצירת מכונות וירטואליות לצרכנים

ב-Cloud Shell, יוצרים את מופע המכונה הווירטואלית של הצרכן, class-e-vm.

gcloud compute instances create class-e-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=class-e-subnet \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'Class-e server !!' | tee /var/www/html/index.html
      EOF"

ב-Cloud Shell, יוצרים את מכונת הצרכן הווירטואלית, proxy-vm, שתשמש כשרת proxy מפורש ל-Vertex AI Pipelines. נשתמש ב-tinyproxy כאפליקציה להעברת תעבורת HTTP דרך שרת proxy, למרות שיש תמיכה גם ב-HTTPS.

gcloud compute instances create proxy-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --can-ip-forward \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=rfc1918-subnet1 \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install tinyproxy -y
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'proxy server !!' | tee /var/www/html/index.html
      EOF"

6. קובץ מצורף עם הרשת של Private Service Connect

קבצים מצורפים עם הרשת הם משאבים אזוריים שמייצגים את הצד של הצרכן בממשק Private Service Connect. משייכים תת-רשת אחת לקובץ מצורף לרשת, והבעלים של השירות המנוהל מקצה כתובות IP לממשק Private Service Connect מתוך תת-הרשת הזו. רשת המשנה צריכה להיות באותו אזור שבו נמצאת ההצמדה לרשת. קובץ מצורף לרשת חייב להיות באותו אזור כמו שירות היצרן.

יצירת קובץ מצורף לרשת

ב-Cloud Shell, יוצרים את קובץ הרשת המצורף.

gcloud compute network-attachments create psc-network-attachment \
    --region=us-central1 \
    --connection-preference=ACCEPT_AUTOMATIC \
    --subnets=intf-subnet

הצגת הקבצים המצורפים לרשת

ב-Cloud Shell, מציגים את רשימת קבצים מצורפים לרשת.

gcloud compute network-attachments list

תיאור של הקבצים המצורפים לרשת

ב-Cloud Shell, מתארים את קובץ הרשת המצורף.

gcloud compute network-attachments describe psc-network-attachment --region=us-central1

חשוב לשים לב לשם של קובץ ה-psc-network-attachment, ‏ psc-network-attachment, שבו ישתמש בעל השירות המנוהל כשיצור את הממשק של Private Service Connect.

כדי לראות את כתובת ה-URL של PSC Network Attachment במסוף Cloud, עוברים אל:

Network Services (שירותי רשת) ‏→ Private Service Connect ‏→ Network Attachment (קובץ מצורף עם הרשת) ‏→ psc-network-attachment

7. תחום DNS פרטי

תצרו אזור Cloud DNS עבור demo.com ותמלאו אותו ברשומות A שמפנות לכתובות ה-IP של מכונות ה-VM. בהמשך, יתבצע פריסה של DNS peering במשימת Vertex AI Pipelines, שתאפשר לה לגשת לרשומות ה-DNS של הצרכן.

ב-Cloud Shell, מבצעים את הפעולות הבאות:

gcloud dns --project=$projectid managed-zones create private-dns-codelab --description="" --dns-name="demo.com." --visibility="private" --networks="https://compute.googleapis.com/compute/v1/projects/$projectid/global/networks/consumer-vpc"

ב-Cloud Shell, מריצים פקודת describe על מכונות ה-VM כדי לקבל את כתובות ה-IP שלהן.

gcloud compute instances describe class-e-vm --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe proxy-vm --zone=us-central1-a | grep  networkIP:

ב-Cloud Shell, יוצרים את קבוצת הרשומות של המכונה הווירטואלית class-e-vm, ומוודאים לעדכן את כתובת ה-IP בהתאם לפלט של הסביבה.

gcloud dns --project=$projectid record-sets create class-e-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="240.0.0.2"

ב-Cloud Shell, יוצרים את קבוצת הרשומות של המכונה הווירטואלית, proxy-vm, ומוודאים שמעדכנים את כתובת ה-IP בהתאם לפלט של הסביבה.

gcloud dns --project=$projectid record-sets create proxy-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.2"

יצירת כלל חומת אש של Cloud כדי לאפשר גישה מממשק ה-PSC

בקטע הבא, יוצרים כלל חומת אש שמאפשר תעבורה שמקורה ב-PSC Network Attachment (חיבור רשת PSC) וגישה למשאבי מחשוב RFC1918 ב-VPC של הצרכנים.

ב-Cloud Shell, יוצרים את כלל חומת האש לתעבורת נתונים נכנסת שמאפשר גישה מתת-הרשת של קובץ ה-PSC Network Attachment אל ה-proxy-vm.

gcloud compute firewall-rules create allow-access-to-proxy \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="192.168.10.0/28" \
    --destination-ranges="10.10.0.0/19" \
    --enable-logging

ב-Cloud Shell, יוצרים את כלל חומת האש לתעבורת נתונים נכנסת שמאפשר גישה מתת-הרשת של מכונת ה-proxy אל תת-הרשת class-e.

gcloud compute firewall-rules create allow-access-to-class-e \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="10.10.10.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

8. עדכון שרת ה-proxy המפורש

בקטע הבא, תצטרכו להתחבר לשרת ה-Proxy המפורש באמצעות SSH ולעדכן את קובץ התצורה tinyproxy.conf, ואז לבצע איפוס.

מ-Cloud Shell

gcloud compute ssh --zone us-central1-a "proxy-vm" --tunnel-through-iap --project $projectid

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

sudo vim /etc/tinyproxy/tinyproxy.conf

# Locate the "Listen" configuration line to restrict listening to only its private IP address of the Proxy-VM, rather than all interfaces. 

Listen 10.10.10.2

# Locate the "Allow" configuration line to allow requests ONLY from the PSC Network Attachment Subnet

Allow 192.168.10.0/24

Save the configs by the following steps:
1. Press the `ESC` key to enter Command Mode.
2. Type `:wq` to save (w) and quit (q).
3. Press `Enter`

Restart the tinyproxy service to apply the changes:
sudo systemctl restart tinyproxy

Validate the tinyproxy service is running:
sudo systemctl status tinyproxy

Perform an exit returning to cloud shell
exit

9. יצירת Jupyter Notebook

בקטע הבא מוסבר איך ליצור Jupyter Notebook. ה-notebook הזה ישמש לפריסה של משימת Vertex AI Pipelines ששולחת wget מ-Vertex AI Pipelines למכונות הבדיקה. נתיב הנתונים בין Vertex AI Pipelines לבין רשת הצרכן שמכילה את המופעים משתמש בממשק רשת של Private Service Connect.

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

בקטע הבא תיצרו חשבון שירות שישויך למופע Vertex AI Workbench שבו נעשה שימוש במדריך.

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

ב-Cloud Shell, יוצרים את חשבון השירות.

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

ב-Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Storage Admin (אדמין אחסון).

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

ב-Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Vertex AI User.

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

ב-Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Artifact Registry Admin.

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

ב-Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Cloud Build Editor.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/cloudbuild.builds.editor"

ב-Cloud Shell, מאפשרים לחשבון השירות של מחברת ה-notebook להשתמש בחשבון השירות שמוגדר כברירת מחדל של Compute Engine.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

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

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

ב-Cloud Shell, יוצרים את המכונה private-client.

gcloud workbench instances create workbench-tutorial --vm-image-project=cloud-notebooks-managed --vm-image-family=workbench-instances --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=rfc1918-subnet1 --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

11. עדכון של סוכן השירות של Vertex AI

‫Vertex AI פועל בשמכם כדי לבצע פעולות כמו קבלת כתובת IP מרשת המשנה של קובץ ה-PSC Network Attachment שמשמש ליצירת ממשק ה-PSC. לשם כך, Vertex AI משתמש בסוכן שירות (שמפורט בהמשך) שנדרשת לו הרשאה של אדמין רשת.

service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com

ב-Cloud Shell, מאתרים את מספר הפרויקט.

gcloud projects describe $projectid | grep projectNumber

ב-Cloud Shell, מאתרים את מספר הפרויקט.

gcloud projects describe $projectid | grep projectNumber
projectNumber: '234086459238'

ב-Cloud Shell, מגדירים את מספר הפרויקט.

projectnumber=YOUR-PROJECT-Number

ב-Cloud Shell, יוצרים חשבון שירות ל-AI Platform. אם כבר יש לכם חשבון שירות בפרויקט, אפשר לדלג על השלב הזה.

gcloud beta services identity create --service=aiplatform.googleapis.com --project=$projectnumber

ב-Cloud Shell, מעדכנים את חשבון סוכן השירות עם התפקיד compute.networkAdmin.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/compute.networkAdmin"

ב-Cloud Shell, מעדכנים את חשבון סוכן השירות בתפקיד dns.peer.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/dns.peer"

עדכון חשבון השירות שמוגדר כברירת מחדל

מפעילים את Compute Engine API ונותנים לחשבון השירות שמוגדר כברירת מחדל גישה ל-Vertex AI. חשוב לזכור: יכול להיות שיעבור זמן עד שהשינוי בהרשאות יתעדכן.

ב-Cloud Shell, מעדכנים את חשבון השירות שמוגדר כברירת מחדל עם התפקיד aiplatform.user.

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

ב-Cloud Shell, מעדכנים את חשבון השירות שמוגדר כברירת מחדל לתפקיד storage.admin

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

ב-Cloud Shell, מעדכנים את חשבון השירות שמוגדר כברירת מחדל לתפקיד storage.admin

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

12. הפעלת Tcpdump

כדי לאמת את קישוריות ה-IP מ-Vertex AI Pipelines, אפשר להשתמש ב-TCPDUMP. כך נוכל לראות את התקשורת שמגיעה מרשת המשנה של רכיב ה-PSC,‏ 192.168.10.0/28, כשמפעילים את בקשת ה-GET מ-Vertex AI Pipelines למכונה הווירטואלית, class-e-vm.demo.com ‏ (240.0.0.0/4).

מ-Cloud Shell, מתחברים באמצעות SSH למכונה הווירטואלית של ה-proxy.

gcloud compute ssh --zone us-central1-a "proxy-vm" --tunnel-through-iap --project $projectid

ממערכת ההפעלה של מכונת ה-proxy, מריצים סינון tcpdump ברשת המשנה של מכונת class-e-vm ובחיבור לרשת PSC.

sudo tcpdump -i any net 240.0.0.0/4 or 192.168.10.0/28 -nn

פותחים כרטיסייה חדשה ב-Cloud Shell, מעדכנים את משתנה הפרויקט ומתחברים באמצעות SSH למכונה הווירטואלית class-e-vm

gcloud compute ssh --zone us-central1-a "class-e-vm" --tunnel-through-iap --project $projectid

ממערכת ההפעלה של מכונת ה-VM class-e-vm, מריצים סינון tcpdump ברשת המשנה של מכונת ה-proxy-vm.

sudo tcpdump -i any net 10.10.10.0/28 -nn

13. פריסת משימה של Vertex AI Pipelines

בקטע הבא ניצור מחברת כדי לבצע wget מוצלח מ-Vertex AI Pipelines לשרת proxy מפורש. כך אפשר להגיע למכונות וירטואליות שאינן RFC 1918, כמו class-e-vm. אין צורך בשרת proxy מפורש כדי ש-Vertex AI Pipelines יוכל לגשת ל-rfc1918-vm, כי היעד שלו הוא כתובת IP של RFC 1918.

מריצים את משימת האימון במכונת Vertex AI Workbench.

במסוף Google Cloud, עוברים לכרטיסייה Instances (מופעים) בדף Vertex AI Workbench.
ליד השם של מופע Vertex AI Workbench (workbench-tutorial), לוחצים על Open JupyterLab. המכונה של Vertex AI Workbench תיפתח ב-JupyterLab.
בוחרים באפשרות 'קובץ' > 'חדש' > 'מחברת'.
בוחרים באפשרות Kernel (ליבה) > Python 3.

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

# Install gcloud
!pip install google-cloud

# Install the pipeline required packages
!pip install --upgrade google-cloud-aiplatform \
                         google-cloud-storage \
                         kfp \
                         google-cloud-pipeline-components

# Import libraries
from time import gmtime, strftime
import json
import requests

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

import json
import requests
import pprint

PROJECT_ID = 'YOUR-PROJECT-ID' #Enter your project ID
PROJECT_NUMBER=!gcloud projects list --filter="project_id:$PROJECT_ID" --format="value(PROJECT_NUMBER)"
PROJECT_NUMBER=str(PROJECT_NUMBER).strip('[').strip(']').strip("'")
print(PROJECT_NUMBER)

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

# us-central1 is used for the codelab
REGION = "us-central1" #@param {type:"string"}
SERVICE_NAME = "aiplatform" #@param {type:"string"}
SERVICE ="{}.googleapis.com".format(SERVICE_NAME)
ENDPOINT="{}-{}.googleapis.com".format(REGION, SERVICE_NAME)
API_VERSION = "v1" # @param {type: "string"}

LOCATION = REGION

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

‫proxy_server = "http://proxy-vm.demo.com:8888" FQDN משויך למכונת ה-VM של ה-proxy שנפרסה ב-VPC של הצרכן. אנחנו משתמשים ב-DNS peering כדי לפתור את ה-FQDN בשלב מאוחר יותר.

%%writefile main.py

import logging
import socket
import sys
import os

def make_api_request(url: str, proxy_vm_ip: str, proxy_vm_port: str):
    """
    Makes a GET request to a non-rfc1918 API and saves the response.

    Args:
        url: The URL of the API to send the request to.
    """
    import requests

    try:
        # response = requests.get(url)
        proxy_server = f"http://proxy-vm.demo.com:8888" # replace with you VM's IP and proxy port.

        proxies = {
          "http": proxy_server,
          "https": proxy_server,
        }

        response = requests.get(url, proxies=proxies)
        logging.info(response.text)

        response.raise_for_status()  # Raise an exception for bad status codes
        logging.info(f"Successfully fetched data from {url}")
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred: {e}")
        raise e

if __name__ == '__main__':
  # Configure logging to print clearly to the console
  logging.basicConfig(
      level=logging.INFO,
      format='%(levelname)s: %(message)s',
      stream=sys.stdout
  )
  url_to_test = os.environ['NONRFC_URL']
  proxy_vm_ip = os.environ['PROXY_VM_IP']
  proxy_vm_port = os.environ['PROXY_VM_PORT']

  logging.info(f"url_to_test: {url_to_test}")
  logging.info(f"proxy_vm_ip: {proxy_vm_ip}")
  logging.info(f"proxy_vm_port: {proxy_vm_port}")
  make_api_request(url_to_test, proxy_vm_ip, proxy_vm_port)

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

%%writefile Dockerfile
FROM python:3.9-slim

RUN apt-get update && \
  apt-get install -y iputils-ping && \
  apt-get install -y wget

RUN pip install cloudml-hypertune requests kfp

COPY main.py /main.py

ENTRYPOINT ["python3", "/main.py"]

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

!gcloud artifacts repositories create pipelines-test-repo-psc --repository-format=docker --location=us-central1

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

IMAGE_PROJECT = PROJECT_ID
IMAGE_REPO = 'pipelines-test-repo-psc' 
IMAGE_NAME = 'nonrfc-ip-call'
TAG = 'v1'

IMAGE_URI= f'us-central1-docker.pkg.dev/{IMAGE_PROJECT}/{IMAGE_REPO}/{IMAGE_NAME}:{TAG}'
IMAGE_URI

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

!gcloud auth configure-docker us-docker.pkg.dev --quiet

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה. אם השגיאה (gcloud.builds.submit) מופיעה, מתעלמים ממנה.

!gcloud builds submit --tag {IMAGE_URI} --region=us-central1

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

הגדרת DNS Peering ל-VPC לצרכנים מתבצעת באמצעות dnsPeeringConfigs (dnsPeeringConfigs) עבור שם הדומיין demo.com.
שרת ה-proxy המפורש, שמוגדר כמשתנה PROXY_VM_IP, הוא proxy-vm.demo.com. הרזולוציה מטופלת באמצעות DNS peering ב-VPC של הלקוח.
יציאה 8888 היא היציאה להאזנה (ברירת מחדל) שמוגדרת ב-tinyproxy
הגישה ל-Wget אל class-e-vm-demo.com מפוענחת באמצעות DNS peering
הקוד מציין את 'psc-network-attachment' ל-Vertex, ומאפשר לו להשתמש ברשת המשנה של קובץ מצורף לרשת כדי לפרוס שני מופעים של ממשק PSC.

import json
from datetime import datetime


JOB_ID_PREFIX='test_psci-nonRFC' #@param {type:"string"}
JOB_ID = '{}_{}'.format(JOB_ID_PREFIX, datetime.now().strftime("%Y%m%d%H%M%S"))

# PSC-I configs

PRODUCER_PROJECT_ID = PROJECT_ID
DNS_DOMAIN = 'class-e-vm.demo.com' #@param {type:"string"}
NON_RFC_URL = f"http://{DNS_DOMAIN}"

PROXY_VM_IP = "proxy-vm.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8888" #@param {type:"string"}

CUSTOM_JOB = {
  "display_name": JOB_ID,
  "job_spec": {
      "worker_pool_specs": [
          {
           "machine_spec": {
             "machine_type": "n1-standard-4",
           },
           "replica_count": 1,
           "container_spec": {
             "image_uri": IMAGE_URI,
             "env": [{
               "name": "NONRFC_URL",
               "value": NON_RFC_URL
             },
             {
               "name": "PROXY_VM_IP",
               "value": PROXY_VM_IP
             },
             {
               "name": "PROXY_VM_PORT",
               "value": PROXY_VM_PORT
             }]
           },
         },
      ],
      "enable_web_access": True,
      "psc_interface_config": {
        "network_attachment": "psc-network-attachment",
        "dns_peering_configs": [
          {
            "domain": "demo.com.",
            "target_project": PROJECT_ID,
            "target_network": "consumer-vpc"
          },
        ]
      },
  }
}

print(json.dumps(CUSTOM_JOB, indent=2))

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

import requests
bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/customJobs/"

print("request_uri: ", request_uri)

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

response_autopush = requests.post(request_uri, json=CUSTOM_JOB, headers=headers)
response = response_autopush
print("response:", response)
if response.reason == 'OK':
  job_name = response.json()['name']
  job_id = job_name.split('/')[-1]
  print("Created Job: ", response.json()['name'])
else:
  print(response.text)

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

# Print KFP SDK version (should be >= 1.6)
! python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

# Print AI Platform version
! python3 -c "from google.cloud import aiplatform; print('AI Platform version: {}'.format(aiplatform.__version__))"

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

BUCKET_URI = "your-unique-bucket" # Provide a globally unique bucket name

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

!gcloud storage buckets create gs://{BUCKET_URI}

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

# pipeline parameters
CACHE_PIPELINE = False # @param {type: "string"}
_DEFAULT_IMAGE = IMAGE_URI
BUCKET_URI = "gs://{BUCKET_URI}"  # @param {type: "string"}
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/intro"
PIPELINE_DISPLAY_NAME = "pipeline_nonRFCIP" # @param {type: "string"}

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

from re import S
import kfp
from kfp import dsl
from kfp.dsl import container_component, ContainerSpec
from kfp import compiler
from google.cloud import aiplatform


# ==== Component with env variable ====

@container_component
def dns_peering_test_op(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    return ContainerSpec(
        image=_DEFAULT_IMAGE,
        command=["bash", "-c"],
        args=[
            """
            apt-get update && apt-get install inetutils-traceroute inetutils-ping netcat-openbsd curl -y

            echo "Local IP(s): $(hostname -I)"

            echo "Attempting to trace route to %s"
            traceroute -w 1 -m 7 "%s"

            echo "Sending curl requests to http://%s via proxy %s:%s and recording trace..."
            if curl -L -v --trace-ascii /dev/stdout -x http://%s:%s "http://%s"; then
                echo "Curl request succeeded!"
            else
                echo "Curl request failed!"
                exit 1
            fi
            """ % (dns_domain, dns_domain, dns_domain, proxy_vm_ip, proxy_vm_port, proxy_vm_ip, proxy_vm_port, dns_domain)

        ]
    )

# ==== Pipeline ====
@dsl.pipeline(
    name="dns-peering-test-pipeline",
    description="Test DNS Peering using env variable",
    pipeline_root=PIPELINE_ROOT,
)
def dns_peering_test_pipeline(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    dns_test_task = dns_peering_test_op(dns_domain=dns_domain, proxy_vm_ip=proxy_vm_ip, proxy_vm_port=proxy_vm_port)
    dns_test_task.set_caching_options(enable_caching=CACHE_PIPELINE)

# ==== Compile pipeline ====
if __name__ == "__main__":
    aiplatform.init(project=PROJECT_ID, location=LOCATION)

    compiler.Compiler().compile(
        pipeline_func=dns_peering_test_pipeline,
        package_path="dns_peering_test_pipeline.yaml",
    )
    print("✅ Pipeline compiled to dns_peering_test_pipeline.yaml")

במחברת JupyterLab, יוצרים תא חדש ומריצים את הפקודה הבאה.

# Define the PipelineJob body; see API Reference https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.pipelineJobs/create

import requests, json
import datetime

bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/pipelineJobs/"

print("request_uri: ", request_uri)

14. אימות של ממשק PSC

אפשר גם לראות את כתובות ה-IP של Network Attachment שמשמשות את Vertex AI Pipelines. לשם כך, עוברים אל:

Network Services (שירותי רשת) ‏→ Private Service Connect ‏→ Network Attachment (קובץ מצורף עם הרשת) ‏→ psc-network-attachment

בוחרים את הפרויקט של הדייר (שם הפרויקט מסתיים ב-tp)

השדה המודגש מציין את כתובת ה-IP שמשמשת את Vertex AI Pipelines מ-PSC Network Attachment.

15. אימות ב-Cloud Logging

הפעלת המשימה ב-Vertex AI Pipelines תימשך כ-14 דקות בפעם הראשונה, והפעלות חוזרות יהיו קצרות יותר. כדי לוודא שהתוצאה תקינה:

עוברים אל Vertex AI → Training → Custom jobs (אימון → משימות בהתאמה אישית)

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

בוחרים באפשרות 'צפייה ביומנים'.

אחרי ש-Cloud Logging יהיה זמין, בוחרים באפשרות Run Query (הפעלת שאילתה) כדי ליצור את הבחירה המודגשת שמופיעה למטה, שמאשרת שהפקודה wget מ-Vertex AI Pipelines אל class-e-vm בוצעה בהצלחה.

16. אימות TCPDump

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

מ-proxy-vm, בודקים את HTTP GET ואת 200 OK

03:05:34.778574 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778946 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.778974 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781999 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906678 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

ממכונה וירטואלית מסוג class-e-vm, מתבוננים ב-HTTP GET וב-200 OK

03:05:34.778768 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778819 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.781815 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781856 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906503 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

17. הסרת המשאבים

ב-Cloud Shell, מוחקים את רכיבי ההדרכה.

gcloud compute instances delete proxy-vm --zone=us-central1-a --quiet

gcloud compute instances delete workbench-tutorial --zone=us-central1-a --quiet

gcloud compute routers delete cloud-router-for-nat --region=us-central1 --quiet

gcloud compute network-attachments delete psc-network-attachment --region=us-central1 --quiet

gcloud compute networks subnets delete intf-subnet rfc1918-subnet1 --region=us-central1 --quiet

gcloud dns record-sets delete class-e-vm.demo.com --zone=private-dns-codelab  --type=A
gcloud dns record-sets delete proxy-vm.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab
gcloud compute networks delete consumer-vpc --quiet

18. מזל טוב

סיימתם להגדיר ולאמת ממשק Private Service Connect עם Vertex AI Pipelines.

יצרתם את התשתית של הצרכן והוספתם קובץ מצורף לרשת שמאפשר ליצרן ליצור מכונת VM עם כמה כרטיסי NIC כדי לגשר על התקשורת בין הצרכן ליצרן. למדתם איך ליצור קישור DNS שכנותי בזמן פריסת שרת proxy מפורש ברשת ה-VPC של הצרכן, שמאפשר קישור למופע של מכונה וירטואלית מסוג class-e-vm שלא ניתן לנתב ישירות מ-Vertex.

‫Cosmopup חושב שסרטוני הדרכה הם מדהימים!!

מה השלב הבא?

קריאה נוספת וסרטונים

סקירה כללית על Private Service Connect

מידע על ממשקי Private Service Connect | VPC | Google Cloud

ממשק PSC של Vertex AI Pipelines Explicit Proxy

1. מבוא

שיקולים לגבי נגישות של Vertex AI PSC-Interface

שיקולים לגבי Vertex AI PSC-Interface VPC-SC

מה תפַתחו

מה תלמדו

מה תצטרכו

‫2. לפני שמתחילים

עדכון הפרויקט כדי לתמוך במדריך

הפעלת API

3. הגדרת צרכן

יצירת VPC של צרכן

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

יצירת תת-רשת של צירוף רשת של Private Service Connect

הגדרת Cloud Router ו-NAT

4. הפעלת IAP

5. יצירת מכונות וירטואליות לצרכנים

6. קובץ מצורף עם הרשת של Private Service Connect

יצירת קובץ מצורף לרשת

הצגת הקבצים המצורפים לרשת

תיאור של הקבצים המצורפים לרשת

7. תחום DNS פרטי

יצירת כלל חומת אש של Cloud כדי לאפשר גישה מממשק ה-PSC

8. עדכון שרת ה-proxy המפורש

9. יצירת Jupyter Notebook

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

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

11. עדכון של סוכן השירות של Vertex AI

עדכון חשבון השירות שמוגדר כברירת מחדל

12. הפעלת Tcpdump

13. פריסת משימה של Vertex AI Pipelines

14. אימות של ממשק PSC

15. אימות ב-Cloud Logging

16. אימות TCPDump

17. הסרת המשאבים

18. מזל טוב

מה השלב הבא?

קריאה נוספת וסרטונים

מאמרי עזרה