Vertex AI Pipelines PSC Interface SWP

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

d7dc28d6567e6283.pngאיור:1

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

  • ממשק Vertex AI PSC יכול לנתב תעבורת נתונים ליעדים ב-VPC או במיקום מקומי בתוך בלוק הכתובות RFC1918.
  • טירגוט של בלוקים של כתובות שאינן RFC-1918 באמצעות ממשק PSC מחייב פריסה של proxy מפורש ב-VPC של הלקוח עם כתובת RFC-1918. בפריסת Vertex AI, צריך להגדיר את ה-proxy יחד עם שם דומיין מלא (FQDN) של נקודת הקצה של היעד. באיור 1 מוצג מצב ה-proxy המפורש של Secure Web Proxy ‏ (SWP) שהוגדר ב-VPC של הצרכן כדי לאפשר ניתוב ל-CIDR הבאים שאינם RFC-1918:
  1. 240.0.0.0/4
  2. 203.0.113.0/24
  3. ‫10.10.20.0/28 לא נדרש proxy, נמצא בטווח RFC-1918.
  4. תעבורת נתונים יוצאת (egress) באינטרנט

חיבור לאינטרנט עבור רשת הדיירים שמנוהלת על ידי Google:

ממשק Vertex AI PSC ללא VPC-SC

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

Vertex AI PSC-Interface with VPC-SC

  • כשהפרויקט שלכם הוא חלק ממערך של VPC Service Controls, הגישה לאינטרנט שמוגדרת כברירת מחדל בדייר שמנוהל על ידי Google נחסמת על ידי המערך כדי למנוע זליגת נתונים.
  • כדי לאפשר לפריסה גישה לאינטרנט הציבורי בתרחיש הזה, צריך להגדיר במפורש נתיב יציאה מאובטח שמעביר את התעבורה דרך ה-VPC שמחובר ל-Vertex AI. אחת הדרכים לעשות זאת היא לפרוס שרת Proxy בתוך רשת ה-VPC עם כתובת RFC 1918, בשילוב עם שער Cloud NAT. שימו לב שאפשר גם להשתמש ב-Secure Web Proxy כדי להעביר את תעבורת הנתונים לאינטרנט. יצירה של Secure Web Proxy יוצרת באופן אוטומטי שער Cloud NAT.

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

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

מה תפַתחו

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

2d095dc2f4de6b4b.pngאיור 2

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

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

מה תלמדו

  • איך יוצרים קובץ מצורף לרשת
  • איך מפיק יכול להשתמש בקובץ מצורף לרשת כדי ליצור ממשק PSC
  • איך יוצרים קישור בין רשתות שכנות (peering) ב-DNS כדי לפתור בעיות בדומיינים פרטיים שהוגדרו ברשת ה-VPC של הצרכן מרשתות ה-VPC המנוהלות של Google
  • איך מעבירים את התנועה מממשק Vertex AI PSC אל Secure Web Proxy
  • איך יוצרים תקשורת למרחב כתובות IP שאינו RFC-1918 מ-Vertex AI Pipelines

מה תצטרכו

פרויקט ב-Google Cloud

הרשאות IAM

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

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

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

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

gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
projectid=YOUR-PROJECT-ID
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"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "networksecurity.googleapis.com"
gcloud services enable "certificatemanager.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 --enable-private-ip-google-access

יצירת תת-רשת ל-proxy בלבד

gcloud compute networks subnets create proxy-only-uscentral1 \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-central1 \
    --network=consumer-vpc \
    --range=10.10.100.0/26

יצירת תת-רשת של צירוף רשת של 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 \
--enable-private-ip-google-access

הגדרות של Cloud Router ו-NAT

Secure Web Proxy של Google Cloud מספק ומנהל באופן אוטומטי שער Cloud NAT ו-Cloud Router משויך באזור שבו הוא נפרס.

4. הפעלת רכישות מתוך האפליקציה

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

  • רלוונטי לכל מכונות ה-VM שרוצים לגשת אליהן באמצעות IAP.
  • מאפשר תעבורת נתונים נכנסת (ingress) מטווח כתובות ה-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 \ 
    --private-network-ip=240.0.0.2

6. Secure Web Proxy

מצב Explicit (או מצב ניתוב Explicit Proxy) של Secure Web Proxy הוא שיטת פריסה שבה צריך להגדיר באופן מפורש את עומסי העבודה של הלקוח כך שישתמשו בכתובת ה-IP הפנימית של SWP או בשם הדומיין שמוגדר במלואו (FQDN) וביציאה כשרת proxy להעברה.

בשלבים הבאים, צריך לשנות את YOUR-PROJECT-ID למזהה הפרויקט

יצירת שרת Proxy לאינטרנט:

ב-Cloud Shell, יוצרים את הקובץ policy.yaml באמצעות עורך טקסט:

cat > policy.yaml << EOF
description: basic Secure Web Proxy policy
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
EOF

ב-Cloud Shell, יוצרים את מדיניות Secure Web Proxy:

gcloud network-security gateway-security-policies import policy1 \
    --source=policy.yaml \
    --location=us-central1

בקטע הבא, יוצרים כלל שמאפשר גישה ל-class-e-vm על סמך המארח sessionMatcher.

ב-Cloud Shell, יוצרים את הקובץ rule1.yaml באמצעות עורך טקסט:

cat > rule1.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-nonrfc-classe
description: Allow nonrfc class-e
enabled: true
priority: 1
basicProfile: ALLOW
sessionMatcher: host() == 'class-e-vm.demo.com'
EOF

בקטע הבא, יוצרים כלל כדי לאפשר ל-Jupyter notebook גישה להתקנת apache2 במכונה הווירטואלית "class-e".

ב-Cloud Shell, יוצרים את הקובץ rule2.yaml באמצעות עורך טקסט:

cat > rule2.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-apache2
description: Allow Apache2 install on class-e VM
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'240.0.0.2')
EOF

ב-Cloud Shell, יוצרים את כלל 1 במדיניות האבטחה:

gcloud network-security gateway-security-policies rules import allow-nonrfc-classe \
    --source=rule1.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

ב-Cloud Shell, יוצרים את כלל 2 במדיניות האבטחה:

gcloud network-security gateway-security-policies rules import allow-apache2 \
    --source=rule2.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

כדי לתמוך ב-Vertex AI Training, צריך להגדיר את שער ה-Secure Web Proxy עם ההגדרות הבאות:

  • יציאת האזנה: צריך להשתמש באותה יציאה שהוגדרה בהגדרות ה-proxy המפורשות של הקוד באפליקציית Vertex AI (למשל, 8080).
  • כתובת: מקצים כתובת IP פרטית מטווח RFC 1918.
  • מצב ניתוב: מגדירים את הערך EXPLICIT_ROUTING_MODE

ב-Cloud Shell, יוצרים קובץ gateway.yaml כדי להגדיר את שער ה-Secure Web Proxy:

cat > gateway.yaml << EOF
name: projects/$projectid/locations/us-central1/gateways/swp1
type: SECURE_WEB_GATEWAY
addresses: ["10.10.10.5"]
ports: [8080]
gatewaySecurityPolicy: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
network: projects/$projectid/global/networks/consumer-vpc
subnetwork: projects/$projectid/regions/us-central1/subnetworks/rfc1918-subnet1
routingMode: EXPLICIT_ROUTING_MODE
EOF

ב-Cloud Shell, יוצרים את מופע Secure Web Proxy:

gcloud network-services gateways import swp1 \
    --source=gateway.yaml \
    --location=us-central1

יכולות לחלוף כמה דקות עד לפריסה של Secure Web Proxy.

e8a4cf23bfc63030.png

7. קובץ מצורף עם הרשת של 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_MANUAL \
    --subnets=intf-subnet

הערה: אין צורך לציין במפורש את מזהה הפרויקט שאושר בקובץ המצורף הזה. אם פרויקט הדיירים בניהול Google מוגדר ב-Vertex AI, הוא יתווסף אוטומטית כאילו הוא הוגדר עם האפשרות 'אישור אוטומטי'.

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

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

gcloud compute network-attachments list

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

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

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

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

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

Network Services → Private Service Connect → Network Attachment → psc-network-attachment

b969cca5242d9c8a.png

8. תחום DNS פרטי

תצרו אזור Cloud DNS עבור demo.com ותמלאו אותו ברשומות A שמפנות לכתובות ה-IP של המכונות הווירטואליות. בהמשך, יתבצע פריסה של 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, יוצרים את קבוצת הרשומות של המכונה הווירטואלית, 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, יוצרים את קבוצת הרשומות עבור Secure Web Proxy, וחשוב לעדכן את כתובת ה-IP בהתאם לפלט של הסביבה.

gcloud dns --project=$projectid record-sets create explicit-swp.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.5"

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

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

ב-Cloud Shell, יוצרים את כלל חומת האש לתעבורת נתונים נכנסת (ingress) שמאפשר גישה מתת-הרשת של שרת proxy בלבד אל תת-הרשת class-e. כי SWP יוזם חיבור עם רשת המשנה של ה-proxy בלבד ככתובת מקור.

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.100.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

9. יצירת Jupyter Notebook

בקטע הבא מוסבר איך ליצור Jupyter 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"

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

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

מעדכנים את חשבון השירות עם התפקיד AI Platform User.

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

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

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

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

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

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

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 משתמש בסוכן שירות (שמפורט בהמשך) שנדרשת לו הרשאת Network Admin.

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

הערה: לפני שמעדכנים את ההרשאות של סוכן השירות, צריך לעבור אל Vertex AI במסוף Cloud כדי לוודא ש-Vertex AI API מופעל.

ב-Cloud Shell:

מאתרים את מספר הפרויקט.

gcloud projects describe $projectid | grep projectNumber

מגדירים את מספר הפרויקט.

projectnumber=YOUR-PROJECT-NUMBER

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

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

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

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

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

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

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

מעדכנים את חשבון השירות שמוגדר כברירת מחדל בתפקיד artifactregistry.admin

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

12. מתקינים את Apache2 ומפעילים את Tcpdump ב-'class-e-vm':

מתוך class-e-vm install apache2 via Secure Web Proxy:

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

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

sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" update
sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" install apache2 -y
sudo service apache2 restart
echo 'class-e Server !!' | sudo tee /var/www/html/index.html

הפעלת סינון tcpdump ברשת המשנה של ה-proxy בלבד, שמשמשת את Secure Web Proxy להעברת תעבורת הנתונים ליעדים.

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

sudo tcpdump -i any net 10.10.100.0/24 -nn

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

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

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

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

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

במחברת 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://explicit-swp.demo.com:8080"
  • שם דומיין מלא (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 nonRFC-1918 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://explicit-swp.demo.com:8080" # replace it with your Secure Web proxy Ip-address and the 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, יוצרים את התא הבא ומריצים אותו. שימו לב לנקודות הבאות:

  • קישור בין רשתות שכנות (peering) ב-DNS לרשתות VPC של צרכנים מוגדר באמצעות dnsPeeringConfigs (dnsPeeringConfigs) עבור שם הדומיין demo.com.
  • שרת ה-proxy לאינטרנט במצב ניתוב מפורש הוא explicit-swp.demo.com. הפענוח מתבצע באמצעות קישור בין רשתות שכנות (peering) ב-DNS בתוך ה-VPC של הצרכן.
  • יציאה 8080 היא יציאת ההאזנה (ברירת מחדל) שמוגדרת ב-Secure Web Proxy
  • ‫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 = "explicit-swp.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8080" #@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)

a2e0b6d6243f26f1.png

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

11e411ea919d3bad.png

15. אימות ב-Cloud Logging

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

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

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

2f467254aa0c2e3a.png

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

8d525d3b152bcc61.png

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

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

16. אימות TCPDump

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

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

XXXXXXXXX@class-e-vm:~$ sudo tcpdump -i any net 10.10.100.0/28 -nn
tcpdump: data link type LINUX_SLL2
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on any, link-type LINUX_SLL2 (Linux cooked v2), snapshot length 262144 bytes
05:51:14.173641 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [S], seq 1747181041, win 65535, options [mss 1420,sackOK,TS val 3942828403 ecr 0,nop,wscale 8], length 0
05:51:14.173668 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [S.], seq 3013226100, ack 1747181042, win 64768, options [mss 1420,sackOK,TS val 1886125065 ecr 3942828403,nop,wscale 7], length 0
05:51:14.174977 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [.], ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 0
05:51:14.175066 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [P.], seq 1:223, ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 222: HTTP: GET / HTTP/1.1
05:51:14.175096 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [.], ack 223, win 505, options [nop,nop,TS val 1886125066 ecr 3942828405], length 0
05:51:14.239042 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [P.], seq 1:246, ack 223, win 505, options [nop,nop,TS val 1886125130 ecr 3942828405], length 245: HTTP: HTTP/1.1 200 OK

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

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

gcloud workbench instances delete workbench-tutorial --project=$projectid --location=us-central1-a

gcloud network-security gateway-security-policies rules delete allow-nonrfc-classe \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-apache2 \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies delete policy1 \
    --location=us-central1
gcloud network-services gateways delete swp1 \
    --location=us-central1

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 explicit-swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab

gcloud computeinstances delete class-e-vm --project=$projectid --zone=us-central1-a --quiet
gcloud compute networks delete consumer-vpc --quiet

18. מזל טוב

סיימתם בהצלחה להגדיר ולאמת חיבור בין ממשק Private Service Connect של Vertex AI Pipelines לבין טווחי כתובות IP שאינם RFC באמצעות Secure Web Proxy.

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

678ba30d64a76795.png

מה השלב הבא?

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

מאמרי עזרה