For version information, see the Distributed Cloud connected release notes.

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

ניהול מכונות וירטואליות

בדף הזה נסביר איך לנהל מכונות וירטואליות בפריסת Google Distributed Cloud במודל מחובר שמופעלת בה VM Runtime ב-Google Distributed Cloud. לפני שמבצעים את השלבים בדף הזה, חשוב להכיר את VM Runtime ב-GDC. רשימה של מערכות הפעלה נתמכות של אורחים זמינה במאמר מערכות הפעלה מאומתות של אורחים עבור VM Runtime ב-GDC.

כדי להבין איך מכונות וירטואליות משמשות כרכיב חיוני בפלטפורמה המחוברת של Distributed Cloud, אפשר לעיין במאמר הרחבת GKE Enterprise לניהול מכונות וירטואליות בפריסה מקומית.

אשכולות מחוברים של Distributed Cloud תומכים בוווב-הוקים של מכונות וירטואליות. כך אפשר לאמת בקשות משתמשים שמופנות לשרת Kubernetes API המקומי ב-Distributed Cloud. בקשות שנדחו יוצרות מידע מפורט על סיבת הדחייה.

הגדרת Symcloud Storage

‫Google Distributed Cloud במודל מחובר משתמש ב-Rakuten Symcloud Storage כפתרון האחסון שלו. ‫Symcloud Storage הוא פתרון של צד שלישי שפועל כשכבת הפשטה של אחסון מקומי בכל צומת שמחובר ל-Distributed Cloud, ומאפשר לעומסי עבודה שפועלים בצמתים אחרים שמחוברים ל-Distributed Cloud לגשת לאחסון המקומי.

שירות Symcloud Storage נפרס מ-Google Cloud Marketplace וכפוף לתנאים שמפורטים בו. ‫Google מספקת תמיכה מוגבלת בשימוש ב-Symcloud Storage עם Distributed Cloud במודל מחובר, ועשויה לפנות לספק הצד השלישי לקבלת עזרה. עדכוני התוכנה של Symcloud Storage כלולים בעדכוני התוכנה המקושרים של Distributed Cloud.

כדי להפעיל את Symcloud Storage למכונות וירטואליות, צריך להגדיר את האשכול של Google Distributed Cloud במודל מחובר באופן הבא. מידע נוסף זמין במאמר בנושא התקנת Symcloud Storage בצומת שמחובר ל-Distributed Cloud.

יוצרים את מרחב השמות robin-admin באמצעות הפקודה הבאה:
```
kubectl create ns robin-admin
```
מקבלים את קובץ הרישיון של Symcloud Storage ומחילים אותו על האשכול באמצעות הפקודה הבאה:
```
kubectl apply -f LICENSE_FILE
```
מחליפים את הערך ב-LICENSE_FILE בנתיב לקובץ הרישיון.

מריצים את הפקודה הבאה כדי לוודא ש-Symcloud Storage פועל:

kubectl describe robincluster

הפקודה מחזירה פלט שדומה לזה:

 Name:         robin
 Namespace:
 Labels:       app.kubernetes.io/instance=robin
               app.kubernetes.io/managed-by=robin.io
               app.kubernetes.io/name=robin
 Annotations:  <none>
 API Version:  manage.robin.io/v1
 Kind:         RobinCluster
 Metadata:
   …
 Spec:
   …
 Status:
   …
   Phase:             Ready
   …

יוצרים את סוג האחסון robin-block-immediate על ידי החלת ההגדרה הבאה על האשכול:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: robin-block-immediate
parameters:
  faultdomain: host
  replication: "3"
  blocksize:   "512"
provisioner: robin
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true

יוצרים את המחלקה robin-snapshotclass של snapshot של נפח אחסון על ידי החלת ההגדרה הבאה על האשכול:

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: robin-snapshotclass
  labels:
    app.kubernetes.io/instance: robin
    app.kubernetes.io/managed-by: robin.io
    app.kubernetes.io/name: robin
  annotations:
    snapshot.storage.kubernetes.io/is-default-class: "true"
driver: robin
deletionPolicy: Delete

משנים את storageprofile עבור סוג האחסון robin-block-immediate עם התוכן הבא ומחילים אותו על האשכול:

apiVersion: cdi.kubevirt.io/v1beta1
kind: StorageProfile
metadata:
  name: robin-block-immediate
spec:
  claimPropertySets:
   – accessModes:
     – ReadWriteMany
  volumeMode: Block

התקנה של כלי הניהול `virtctl`

כדי לנהל מכונות וירטואליות באשכול שמחובר ל-Distributed Cloud, צריך את כלי הלקוח virtctl. כדי להתקין את הכלי, מבצעים את השלבים הבאים:

מתקינים את כלי הלקוח virtctl כפלאגין של kubectl:

export VERSION=v1.3.1-anthos1.35-gke.39
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl ./virtctl
sudo mv ./virtctl /usr/local/bin/virtctl
cd /usr/local/bin
sudo ln -s virtctl kubectl-virt
sudo chmod a+x virtctl
cd -

מוודאים שהפלאגין virt מותקן:
```
kubectl plugin list
```
אם הפלאגין הותקן בהצלחה, הפלט של הפקודה יכלול את kubectl-virt כאחד מהפלאגינים.

יצירת קטגוריה של Cloud Storage לקובצי אימג' של מכונות וירטואליות

כדי ליצור קטגוריית Cloud Storage לתמונות של המכונות הווירטואליות, צריך לבצע את השלבים שמפורטים בקטע הזה. ה-Bucket משתמש באיחוד זהויות של עומסי עבודה (WIF) כדי להעניק לחשבון שירות של Kubernetes גישה ישירה ל-Bucket. אם כבר יש לכם מאגר תמונות, אפשר לדלג על הקטע הזה.

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

פועלים לפי ההוראות במאמר יצירת קטגוריות כדי ליצור קטגוריה.
יוצרים Kubernetes ServiceAccount במרחב השמות של המכונה הווירטואלית של היעד:
```
export VM_NAMESPACE=NAMESPACE
export KUBERNETES_SERVICEACCOUNT=KUBERNETES_SERVICEACCOUNT
kubectl create serviceaccount ${KUBERNETES_SERVICEACCOUNT} -n ${VM_NAMESPACE}
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫NAMESPACE: מרחב השמות של המכונה הווירטואלית היעד.
- ‫KUBERNETES_SERVICEACCOUNT: שם משמעותי לחשבון השירות הזה ב-Kubernetes.
מאתרים את השם של מאגר הזהויות של עומסי העבודה וספק הזהויות של האשכול:
```
gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫MEMBERSHIP_ID: שם החברות של האשכול ב-Fleet. בדרך כלל זה השם של האשכול.
- ‫FLEET_PROJECT_ID: המזהה של פרויקט המארח של ה-Fleet. Google Cloud
הפקודה מחזירה פלט שדומה לזה:
```
IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL
```
בפלט, שימו לב לערכים הבאים:
- ‫IDENTITY_PROVIDER: ספק הזהויות של האשכול הזה.
- ‫WORKLOAD_IDENTITY_POOL: הוא השם של מאגר הזהויות של עומסי עבודה שמשויך ל-Fleet. השם הוא בפורמט FLEET_PROJECT_ID.svc.id.goog. מידע נוסף על הפקודה בשלב הזה זמין במאמר שימוש ב-Fleet איחוד זהויות של עומסי עבודה (WIF) באפליקציות.
מקצים את התפקיד 'צפייה באובייקט אחסון' (roles/storage.objectViewer) בקטגוריה לחשבון השירות של Kubernetes:
```
export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
export FLEET_PROJECT_NUMBER=FLEET_PROJECT_NUMBER
export KUBERNETES_SERVICEACCOUNT=KUBERNETES_SERVICEACCOUNT
export VM_NAMESPACE=NAMESPACE
export WI_POOL=WORKLOAD_IDENTITY_POOL
gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
   --member="principal://iam.googleapis.com/projects/${FLEET_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${WI_POOL}/subject/ns/${VM_NAMESPACE}/sa/${KUBERNETES_SERVICEACCOUNT}" \
   --role="roles/storage.objectViewer" \
   --project=${BUCKET_PROJECT_ID} \
   --condition="IAM_CONDITION" \
   --condition-from-file="IAM_CONDITION_FILE"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫BUCKET_PROJECT_ID: המזהה של Google Cloud הפרויקט שמארח את הקטגוריה.
- ‫FLEET_PROJECT_NUMBER: מספר הפרויקט של Google Cloud פרויקט המארח של ה-Fleet.
- ‫KUBERNETES_SERVICEACCOUNT: השם של חשבון השירות של Kubernetes שמהווה את היעד.
- ‫NAMESPACE: מרחב השמות של המכונה הווירטואלית היעד.
- ‫WORKLOAD_IDENTITY_POOL: השם של מאגר הזהויות של עומסי העבודה באשכול.
- ‫IAM_CONDITION: אופציונלי. מציין את תנאי ה-IAM שבהם צריך להשתמש כדי להגביל את הגישה לאשכולות ספציפיים ב-Fleet. אם לא מציינים תנאים או אם מציינים את הערך None, לא יחולו תנאי IAM.
- ‫IAM_CONDITION_FILE: אופציונלי; מציין את הקובץ שמכיל את תנאי IAM להגבלת הגישה לאשכולות ספציפיים ב-Fleet. אם לא מציינים את הדגל, לא חלים תנאי IAM, אלא אם מציינים את --condition הדגל ומגדירים לו ערך שונה מ-None.
מאחסנים את התמונות בדלי.

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

הגבלת הגישה לקטגוריה באמצעות תנאי IAM

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

יוצרים את קובץ תנאי ה-IAM:

cat <<EOF > iam_condition.yaml
> expression: request.auth.claims.google.providerId == '$IDENTITY_PROVIDER'
title: allow_only_this_cluster
> EOF

מחילים את קובץ תנאי ה-IAM כשנותנים לחשבון השירות של Kubernetes גישה לקטגוריה:

gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
  --project="${BUCKET_PROJECT_ID}" \
  --role="roles/storage.objectViewer" \
  --member="principal://iam.googleapis.com/projects/${FLEET_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${WI_POOL}/subject/ns/${VM_NAMESPACE}/sa/${KUBERNETES_SERVICEACCOUNT}" \
  --condition-from-file=iam_condition.yaml

יצירת דיסק של מכונה וירטואלית מקובץ אימג' של מכונה וירטואלית

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

יצירת דיסק מקובץ אימג' שמאוחסן ב-Cloud Storage

יוצרים דיסק של מכונה וירטואלית ממכונה וירטואלית שמאוחסנת בקטגוריה של Cloud Storage על ידי החלת ההגדרה הבאה על האשכול:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   source:
     gcs:
       url: gs://${BUCKET_PROJECT_ID}-vm-images/IMAGE_FILE_PATH
       serviceAccount: KUBERNETES_SERVICEACCOUNT
   size: DISK_SIZE
   storageClassName: robin-block-immediate

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

‫DISK_NAME: השם של הדיסק של המכונה הווירטואלית.
‫NAMESPACE: מרחב השמות של המכונה הווירטואלית היעד.
‫IMAGE_FILE_PATH: הנתיב המלא ושם הקובץ של תמונת המכונה הווירטואלית. כדי לקבל את הנתיב הזה, לוחצים לחיצה ימנית על התמונה במסוף Google Cloud ובוחרים באפשרות העתקת URI של gsutil.
‫KUBERNETES_SERVICEACCOUNT: חשבון השירות של Kubernetes להורדת קובצי אימג' של מכונות וירטואליות שיצרתם קודם.
‫DISK_SIZE: גודל היעד של הדיסק. הערך הזה צריך להיות גדול יותר מהערך virtual-size של קובץ האימג' של המכונה הווירטואלית. אפשר למצוא את הערך הזה באמצעות הפקודה qemu-img info DISK_SIZE.

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

יצירת דיסק מתמונה שמאוחסנת בשירות של צד שלישי

יש לכם גם אפשרות להשתמש ב-http, ב-https, ב-S3 או במאגר תמונות כדי לאחסן את תמונות המכונות הווירטואליות. אם שירות האחסון דורש פרטי כניסה כדי לגשת אליו, צריך להמיר את פרטי הכניסה האלה לסוד ולציין את הסוד הזה באמצעות השדה secretRef.

לדוגמה:

source:
    http/s3/registry:
       url:
       secretRef: "SECRET_NAME" # optional

מחליפים את SECRET_NAME בשם הסוד.

מידע נוסף זמין במאמר בנושא מקור HTTP/S3/GCS/Registry.

יצירת דיסק ריק

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

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   size: DISK_SIZE
   storageClassName: robin-block-immediate

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

‫DISK_NAME: השם של הדיסק של המכונה הווירטואלית.
‫NAMESPACE: מרחב השמות של היעד.
‫DISK_SIZE: גודל הדיסק הרצוי בגיביבייט. הערך הזה צריך להיות גדול יותר מהערך virtual-size של קובץ האימג' של המכונה הווירטואלית. אפשר למצוא את הערך הזה באמצעות הפקודה qemu-img info DISK_SIZE.

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

הגדרת רשתות וירטואליות

פועלים לפי השלבים שבקטע Networking כדי להגדיר את הרשת הווירטואלית למכונות הווירטואליות.

יצירת מכונה וירטואלית

כדי ליצור מכונה וירטואלית בפריסת שרת מחובר של Distributed Cloud, צריך לבצע את השלבים שמפורטים בקטע הזה. ההוראות בקטע הזה הן דוגמאות שממחישות הגדרות לתרחישים שונים. מידע מפורט על הגדרת מכונות וירטואליות זמין במאמר יצירת מכונה וירטואלית עם משאבי CPU וזיכרון ספציפיים באמצעות VM Runtime ב-GDC.

הקצאת המשאבים למכונות וירטואליות מוגבלת על ידי פרופילי החומרה של הפריסה המחוברת שלכם ל-Distributed Cloud, כמו חומרה G1 או G2. אי אפשר להגדיל את הגודל של מכונה וירטואלית יחידה מעבר לגודל של המכונה הפיזית המחוברת ל-Distributed Cloud שבה היא פועלת.

יצירת מכונה וירטואלית באמצעות Google Cloud המסוף

כדי ליצור מכונה וירטואלית באמצעות מסוף Google Cloud :

נכנסים לדף Clusters במסוף Google Cloud .
מעבר אל Clusters
בוחרים את פרויקט היעד Google Cloud .
(אופציונלי) אם עדיין לא עשיתם זאת, נכנסים לאשכול היעד:
1. בחלונית הניווט הימנית, לוחצים על Clusters (אשכולות).
2. ברשימה Anthos Managed Clusters (אשכולות מנוהלים של Anthos), לוחצים על אשכול היעד.
3. בחלונית המידע בצד שמאל, לוחצים על כניסה.
4. בתיבת הדו-שיח הקופצת שמופיעה, בוחרים את שיטת האימות המועדפת, מזינים את פרטי הכניסה ולוחצים על כניסה.
עוברים לדף Virtual Machines.
מעבר אל Virtual Machines
לוחצים על יצירה.
בקטע Basics (פרטים בסיסיים), מבצעים את הפעולות הבאות:
1. בשדה Name, מזינים שם משמעותי למכונה הווירטואלית.
2. בשדה Select cluster (בחירת אשכול), בוחרים את אשכול היעד של המכונה הווירטואלית.
3. בשדה Namespace, בוחרים את מרחב השמות של היעד.
4. בשדה סוג מערכת ההפעלה, בוחרים את מערכת ההפעלה לטירגוט.
5. (אופציונלי) אם רוצים להוסיף תווית אחת או יותר להגדרות של המכונה הווירטואלית, לוחצים על הוספת תווית.
בקטע Machine Configuration, מבצעים אחת מהפעולות הבאות:
- אם רוצים לציין את מספר ליבות ה-CPU הווירטואליות ואת כמות הזיכרון של המכונה הווירטואלית הזו, בוחרים באפשרות הגדרה בהתאמה אישית, מזינים את ערכי היעד ולוחצים על הבא.
- אם רוצים להשתמש במספר מוגדר מראש של vCPU ובכמות מוגדרת מראש של זיכרון למכונה הווירטואלית הזו, בוחרים באפשרות Standard Configuration (הגדרה רגילה), בוחרים הגדרת מכונה מהרשימה הנפתחת Machine Type (סוג המכונה) ולוחצים על NEXT (הבא).
בקטע Storage (אחסון), מבצעים אחת מהפעולות הבאות:
- אם רוצים ליצור דיסק וירטואלי חדש למכונה הווירטואלית הזו, בוחרים באפשרות הוספת דיסק חדש ומזינים שם משמעותי בשדה שם, גודל בגיגה-בייט בשדה GiB וכתובת URL בשדה תמונה.
- אם רוצים להשתמש בדיסק וירטואלי קיים למכונה הווירטואלית הזו, בוחרים באפשרות בחירת דיסק קיים ובוחרים את תמונת הדיסק הרצויה מהרשימה הנפתחת בחירת דיסק.
- מציינים אם רוצים שהדיסק יהיה לקריאה בלבד, ואם הוא יימחק אוטומטית כשמחקקים את המכונה הווירטואלית הזו, באמצעות תיבות הסימון לקריאה בלבד ומחיקה אוטומטית.
- מציינים מנהל התקן של דיסק וירטואלי בתפריט הנפתח Driver (מנהל התקן).
- כדי להוסיף עוד דיסק למכונה הווירטואלית, לוחצים על הוספת דיסק בקטע דיסקים נוספים.
- לוחצים על הבא.
בקטע Network (רשת), מבצעים את הפעולות הבאות:
1. בקטע Default network interface, מציינים את השם של ממשק הרשת הראשי של המכונה הווירטואלית בשדה Interface name.
2. בוחרים את סוג הרשת המתאים מהרשימה הנפתחת סוג הרשת.
3. מסמנים את התיבה Allow external access (אפשר גישה חיצונית) כדי לאפשר גישה חיצונית לממשק הרשת הזה. אם מפעילים את האפשרות הזו, צריך להזין רשימה מופרדת בפסיקים של יציאות כדי לחשוף אותן חיצונית בשדה יציאות חשופות.
4. אם רוצים להוסיף מכונת רשת משנית אחת או יותר למכונה הווירטואלית הזו, לוחצים על הוספת ממשק רשת.
5. לוחצים על הבא.
בקטע אפשרויות מתקדמות, משתמשים בתיבת הסימון הפעלה מחדש אוטומטית בעדכון כדי לציין אם להפעיל מחדש את המכונה הווירטואלית הזו אחרי שהתוכנה המחוברת ל-Distributed Cloud באשכול היעד תעודכן.
בקטע Firmware (קושחה):
1. בשדה סוג Bootloader, בוחרים את סוג הקושחה של היעד. אם בוחרים ב-UEFI firmware, אפשר להפעיל את האפשרות Secure boot (אתחול מאובטח) באמצעות תיבת הסימון.
2. מציינים מספר סידורי למכונה הווירטואלית הזו בשדה Serial.
3. מציינים מזהה ייחודי אוניברסלי (UUID) למכונה הווירטואלית בשדה UUID.
בקטע Cloud-init, מציינים ערך סודי של נתוני משתמש בשדה User data secret.
לוחצים על CREATE VM (יצירת מכונה וירטואלית) כדי ליצור את המכונה הווירטואלית.

יצירת מכונה וירטואלית מקובץ YAML

כדי ליצור מכונה וירטואלית מקובץ תצורה בפורמט YAML:

נכנסים לדף Clusters במסוף Google Cloud .
מעבר אל Clusters
בוחרים את פרויקט היעד Google Cloud .
(אופציונלי) אם עדיין לא עשיתם זאת, נכנסים לאשכול היעד:
1. בחלונית הניווט הימנית, לוחצים על Clusters (אשכולות).
2. ברשימה Anthos Managed Clusters (אשכולות מנוהלים של Anthos), לוחצים על אשכול היעד.
3. בחלונית המידע בצד שמאל, לוחצים על כניסה.
4. בתיבת הדו-שיח הקופצת שמופיעה, בוחרים את שיטת האימות המועדפת, מזינים את פרטי הכניסה ולוחצים על כניסה.
עוברים לדף Virtual Machines.
מעבר אל Virtual Machines
לוחצים על CREATE WITH YAML.
בשדה Select cluster (בחירת אשכול), בוחרים את אשכול היעד של המכונה הווירטואלית.
מדביקים את ההגדרה של המכונה הווירטואלית בפורמט YAML בשדה YAML. פרטים על שדות YAML הנתמכים זמינים במפרט של מכונות וירטואליות.
לוחצים על יצירה.

יצירת מכונה וירטואלית מקובץ אימג' של דיסק שאפשר לאתחל ממנו

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

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: my-virtual-machine
  namespace: NAMESPACE
spec:
  osType: Linux/Windows
  # guestEnvironment: {} # uncomment this line to disable guest environment
  priorityClassName: PRIORITY_CLASS
  compute:
    cpu:
      vcpus: 6
    memory:
      capacity: 8Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      ipAddresses:
        - IP_ADDRESS/PREFIX
  disks:
    - virtualMachineDiskName: DISK_NAME
      boot: true
    - virtualMachineDiskName: DISK_NAME

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

‫NAMESPACE: מרחב השמות של היעד.
‫PRIORITY_CLASS: מחלקת העדיפות של המכונה הווירטואלית הזו. מחלקת עדיפות היא טווח של ערכי עדיפות. אפשר להשתמש ב-kubectl get priorityclass כדי לראות רשימה של מחלקות עדיפות נתמכות. עדיפות תזמון גבוהה יותר מקטינה את הסיכוי לפינוי של מכונה וירטואלית כשמשאבי הצומת מוגבלים. אם לא מציינים ערך, המכונה הווירטואלית מקבלת את ערך ברירת המחדל של העדיפות הנמוכה ביותר.
‫NETWORK_NAME: השם של רשת L2 שאליה רוצים לצרף את הממשק של המכונה הווירטואלית.
‫DISK_NAME: השמות של הדיסקים של המכונה הווירטואלית הזו.
‫vcpus: מספר המעבדים הווירטואליים להקצאה למכונה הווירטואלית.
‫capacity: כמות הזיכרון להקצאה למכונה הווירטואלית. לדוגמה, 4Gi או 8Gi.
‫ipAddresses: אופציונלי. מאפשר הקצאת כתובת IP סטטית למכונה הווירטואלית. אם רשת L2 הבסיסית תומכת ב-DHCP חיצוני, אפשר להשמיט את ipAddresses כדי לאפשר הקצאה דינמית.

שימוש ב-`cloud-init` API כדי להפעיל מכונות וירטואליות

‫cloud-init API הוא דרך סטנדרטית להפעיל מכונה וירטואלית בענן. אפשר להשתמש ב-cloud-init כדי להגדיר קבצים, משתמשים והיבטים אחרים של המכונה הווירטואלית.

כדי לוודא את התאימות, צריך לאמת את cloud-init שגרות ההפעלה. לפני שמשתמשים בהגדרה בסביבת הייצור, צריך להחיל את ההגדרה על מכונת VM לבדיקה כדי לוודא שהיא מאותחלת בהצלחה.

הדוגמאות הבאות הן כלליות, וחובה לבדוק אותן בסביבה שלכם.

אוטומציה של הגדרת מכונות וירטואליות באמצעות `cloud-init` נתוני משתמש

‫VM Runtime ב-GDC תומך בcloud-init נתוני משתמשים למכונות וירטואליות של Linux. אפשר לציין את נתוני המשתמש כמחרוזת טקסט פשוט, כמחרוזת בקידוד base64 או על ידי הפניה ל-Kubernetes Secret.

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

בדוגמה הבאה מוצג מניפסט VirtualMachine שכולל נתוני משתמש בטקסט פשוט cloud-init להרצת פקודה כשהמכונה הווירטואלית מופעלת:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  osType: Linux
  cloudInit:
    noCloud:
      userData: |
        #cloud-config
        runcmd:
          - echo "Hello World" > /tmp/hello.txt

מחליפים את VM_NAME בשם המכונה הווירטואלית.

כדי ליצור את ה-VM עם נתוני cloud-init, שומרים את המניפסט כ-vm-cloud-init.yaml ומחילים אותו על האשכול באמצעות הפעלת הפקודה kubectl apply:

kubectl apply -f vm-cloud-init.yaml

פתרון בעיות `cloud-init`

אם נתקלים בבעיות ב-cloud-init, כדאי לבדוק את היומנים בתוך המכונה הווירטואלית. בדרך כלל אפשר למצוא את היומנים בספריות הבאות:

/var/log/cloud-init.log
/var/log/cloud-init-output.log

יצירת מכונה וירטואלית מקובץ אימג' של דיסק אופטי ISO

אתם יכולים ליצור מכונה וירטואלית (VM) של Windows שמבצעת אתחול מתמונת ISO באמצעות VM Runtime ב-GDC. היכולת הזו מאפשרת לכם להעביר אפליקציות ארגוניות מדור קודם שמבוססות על Windows, תוכנות צד שלישי ייעודיות או מערכות קופה מותאמות אישית ישירות לאשכולות המחוברים של Distributed Cloud.

תמונות שמשמשות לדיסקים של מכונות וירטואליות מיובאות מקטגוריית תמונות מקושרת של Distributed Cloud. לפני שיוצרים את המניפסטים, צריך להוריד את קובץ ה-ISO של ההתקנה של Windows ואת קובץ ה-ISO של מנהלי ההתקנים של KubeVirt virtio ולהעלות אותם לקטגוריית התמונות. כדי להבטיח בנייה אמינה וניתנת לשחזור של מכונות וירטואליות, מומלץ לשמור עותק מאומת של קובץ ה-ISO של מנהלי ההתקנים במאגר פנימי או להכין אותו מראש ב-Cloud Storage.

יצירת קובצי המניפסט

כדי לבצע אתחול מקובץ ISO של Windows, אתם צריכים את קובצי המניפסט הבאים:

‫VirtualMachineDisk שמכיל את קובץ ה-ISO של Windows.
‫VirtualMachineDisk שמכיל את הדרייברים של KubeVirt Windows virtio.
דיסק VirtualMachineDisk ריק שישמש כדיסק האתחול שבו יותקן Windows.

בדוגמאות הבאות מוצגים קובצי ה-manifest של VirtualMachineDisk לשלושת הדיסקים הנדרשים.

במניפסטים, מחליפים את הערכים הבאים:

‫BUCKET_PROJECT_ID: מזהה הפרויקט שבו נמצאת קטגוריית התמונות.
‫KUBERNETES_SERVICEACCOUNT: חשבון השירות ב-Kubernetes עם הרשאות קריאה מהמאגר.

ה-PVC‏ size שנדרש במניפסטים חייב להיות תמיד גדול או שווה לגודל הווירטואלי המדויק של ה-ISO.

דיסק ISO של Windows

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-iso
spec:
  size: 10Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/windows.iso
      serviceAccount: KUBERNETES_SERVICEACCOUNT

דיסק של מנהלי התקנים של VirtIO

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: virtio-driver
spec:
  size: 1Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/virtio-win.iso
      serviceAccount: KUBERNETES_SERVICEACCOUNT

דיסק אתחול ריק

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-vm-boot-dv
spec:
  size: 40Gi
  storageClassName: robin-block-immediate

יצירת הדיסקים

כדי ליצור את הדיסקים האלה, שומרים את VirtualMachineDisk המניפסטים ומחילים אותם על האשכול באמצעות הפעלת הפקודה kubectl apply:

kubectl apply -f windows-iso.yaml
kubectl apply -f virtio-driver.yaml
kubectl apply -f windows-vm-boot-dv.yaml

יצירת מכונה וירטואלית של Windows

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

בדוגמה הבאה מוצג מניפסט של VirtualMachine:

‫

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  labels:
    kubevirt.io/vm: windows-vm
  name: windows-vm
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: windows-vm-boot-dv
      boot: true
    - virtualMachineDiskName: windows-iso
    - virtualMachineDiskName: virtio-driver
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
      ipAddresses:
        - IP_ADDRESS/PREFIX

כדי ליצור את המכונה הווירטואלית, שומרים את המניפסט כ-windows-vm.yaml ומחילים אותו על האשכול באמצעות הפקודה kubectl apply:

kubectl apply -f windows-vm.yaml

מתחברים ומשלימים את ההתקנה

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

כדי להתחבר למכונה הווירטואלית באמצעות VNC, משתמשים בכלי virtctl או בתוסף kubectl virt:
```
virtctl vnc windows-vm
```
לחלופין, אם התקנתם את virtctl כפלאגין של kubectl:
```
kubectl virt vnc windows-vm
```
מידע נוסף על virtctl זמין במסמכי התיעוד של KubeVirt.
פועלים לפי ההוראות שמוצגות בכלי ההתקנה של Windows. כשמופיעה בקשה, בוחרים באפשרות התקנה בהתאמה אישית.
כשמופיעה בקשה, טוענים את מנהלי ההתקנים virtio לאחסון ולרשת, ומעיינים בדיסק virtio-driver המצורף.
משלימים את ההתקנה.

גישה באמצעות פרוטוקול Remote Desktop

אחרי שמתקינים ומפעילים את פרוטוקול Remote Desktop ‏ (RDP) במערכת ההפעלה של האורח, אפשר לגשת למכונה הווירטואלית דרך RDP.

מכיוון שהמכונה הווירטואלית מצורפת לרשת L2, אפשר להגיע אליה ישירות מחוץ לאשכול באמצעות כתובת ה-IP שהוקצתה לה (לדוגמה, 10.223.237.10). מתחברים לכתובת ה-IP הזו ביציאה 3389 באמצעות לקוח RDP. מוודאים שאפשר להגיע לכתובת ה-IP הפנימית של L2 ממכונת הלקוח דרך חומת האש הארגונית וכללי הניתוב.

יצירת מכונה וירטואלית עם תמיכה ב-GPU

כדי ליצור מכונה וירטואלית שמוגדרת בהתאם לדרישות העסקיות שלכם, משלימים את השלבים שמתוארים בדף הזה, ואז משלימים את השלבים במאמר הגדרה של מכונה וירטואלית לשימוש במשאבי GPU.

מפרט מכונה וירטואלית

בטבלה הבאה מתוארים השדות העיקריים במפרט VirtualMachine. אפשר להשתמש בשדות האלה כשמגדירים מניפסט YAML של מכונה וירטואלית כדי להחיל אותו על האשכול באמצעות kubectl apply, או כשמשתמשים באפשרות יצירה באמצעות YAML במסוף Google Cloud .

שדה	תיאור	חובה
`apiVersion`	חייב להיות `vm.cluster.gke.io/v1`.	חובה
`kind`	חייב להיות `VirtualMachine`.	חובה
`metadata.name`	שם ייחודי למכונה הווירטואלית.	חובה
`metadata.namespace`	מרחב השמות של Kubernetes שבו המכונה הווירטואלית פועלת.	חובה
`spec.osType`	סוג מערכת ההפעלה של האורח. ערכים נתמכים: `Linux` ו-`Windows`.	חובה
`spec.guestEnvironment`	הגדרת סביבת האורח. אם לא מציינים את ההגדרה, סביבת האורח מופעלת כברירת מחדל. כדי להשבית את ההגדרה, מגדירים את הערך `{}`.	אופציונלי
`spec.priorityClassName`	סיווג העדיפות של המכונה הווירטואלית. עדיפות גבוהה יותר מקטינה את הסיכוי להוצאה מהזיכרון.	אופציונלי
`spec.compute`	הגדרת משאבי החישוב של המכונה הווירטואלית.	חובה
`spec.compute.cpu.vcpus`	מספר המעבדים הווירטואליים להקצאה. הערכים הקבילים הם 1 עד 96.	חובה
`spec.compute.memory.capacity`	נפח הזיכרון, לדוגמה, `8Gi`.	חובה
`spec.interfaces`	רשימה של ממשקי רשת למכונה הווירטואלית.	חובה
`spec.interfaces[].name`	השם של הממשק, לדוגמה, `eth0`.	חובה
`spec.interfaces[].networkName`	השם של רשת המשנה שאליה רוצים להתחבר, שמופה למשאב `Network` באשכול.	חובה
`spec.interfaces[].ipAddresses`	כתובות IP סטטיות להקצאה לממשק הזה. אם לא מופעל DHCP ברשת המשנה, צריך לציין כתובת IP סטטית.	אופציונלי
`spec.disks`	רשימת הדיסקים לצירוף למכונה הווירטואלית.	חובה
`spec.disks[].virtualMachineDiskName`	השם של משאב `VirtualMachineDisk`.	חובה
`spec.disks[].boot`	מגדירים את הדיסק לערך `true`. אפשר לסמן רק דיסק אחד כניתן לאתחול.	אופציונלי

גישה למכונה וירטואלית

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

דרישות הרשת לגישה ישירה

כדי לגשת למכונה וירטואלית ישירות מהרשת המקומית בלי להשתמש בשירות Kubernetes LoadBalancer, צריך להגדיר את רכיבי הרשת הלוגיים והפיזיים. ‫Distributed Cloud connected מנהל באופן אוטומטי את משאבי הרשת בתוך האשכול, אבל צריך להגדיר את הרשת החיצונית ואת הממשק של המכונה הווירטואלית.

הגדרת רשת משנה (VLAN): יצירת רשת משנה עם מזהה VLAN ספציפי באמצעות Distributed Cloud Edge Network API, באמצעות gcloud או ה-API. ‫Distributed Cloud במודל מחובר מסנכרן אוטומטית את ההגדרה הזו עם האשכול. אין צורך ליצור ידנית משאבי רשת של Kubernetes. איך יוצרים ומנהלים רשתות משנה
הגדרת הרשת המקומית: האדמין של הרשת צריך להגדיר את המתגים הפיזיים והנתבים שמחוברים לשרתים של Distributed Cloud כך:
- מאפשרים את מזהה ה-VLAN המוגדר ביציאות המתג (VLAN trunking).
- מפעילים ניתוב בין הרשת המקומית לבין רשת המשנה. אם Border Gateway Protocol‏ (BGP), פרוטוקול ניתוב דינמי, מוגדר בנתבים המחוברים ל-Distributed Cloud, המסלולים האלה יפורסמו באופן אוטומטי אחרי יצירת רשת המשנה. אחרת, תצטרכו להגדיר ניתוב סטטי בנתבים הפיזיים כדי לנתב את התנועה לטווח כתובות ה-IP (CIDR) של רשת המשנה לצמתים המחוברים של Distributed Cloud.
הגדרת הממשק של המכונה הווירטואלית: בקובץ התצורה VirtualMachine בפורמט YAML, מגדירים את המכונה הווירטואלית כך שתשתמש ברשת המשנה הזו על ידי ציון שם הרשת בשדה spec.interfaces. מידע נוסף זמין במאמר הפניה למפרט של מכונה וירטואלית.

קבלת פרטי כניסה למכונות וירטואליות של Linux

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

מפעילים את סביבת האורח של Linux במכונה הווירטואלית של היעד על ידי החלת ההגדרה הבאה על האשכול:

kind: VirtualMachine
metadata:
 name: my-virtual-machine
 namespace: my-vm-namespace
spec:
 osType: Linux
 guestEnvironment: // enabled by default; disable with guestEnvironment: {}
   accessManagement:
    enable: true

מריצים את הפקודה הבאה כדי ליצור קובץ id_rsa.pub שמכיל זוג מפתחות SSH:
```
ssh-keygen -t rsa
```
יוצרים משאב VirtualMachineAccessRequest על ידי החלת ההגדרה הבאה על האשכול:
```
apiVersion: vm.cluster.gke.io/v1alpha1
kind: VirtualMachineAccessRequest
metadata:
 name: RESOURCE_NAME
 namespace: NAMESPACE
spec:
  vm: VM_NAME
  user: USER_NAME
  ssh:
    key: RSA_KEY
    ttl: 2h
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫RESOURCE_NAME: שם תיאורי של משאב בקשת הגישה למכונה הווירטואלית.
- ‫NAMESPACE: מרחב השמות של היעד.
- ‫VM_NAME: השם של המכונה הווירטואלית של היעד.
- ‫USER_NAME: השם של המשתמש שמקבל גישה.
- ‫RSA_KEY: התוכן של קובץ id_rsa.pub שיצרתם בשלב הקודם.
כדי לבדוק את הסטטוס של בקשת הגישה, מריצים את הפקודה kubectl get:
```
kubectl get vmar
```
אם הפקודה מחזירה סטטוס Configured, ממשיכים לשלב הבא.
ניגשים למכונה הווירטואלית באמצעות SSH. אם המכונה הווירטואלית מחוברת לרשת המקומית, אפשר לגשת אליה ישירות באמצעות SSH:
```
ssh USERNAME@VM_IP_ADDRESS -i PATH_TO_KEY
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫USERNAME: שם המשתמש שמשמש לכניסה, לדוגמה, המשתמש שהוגדר במשאב VirtualMachineAccessRequest.
- ‫VM_IP_ADDRESS: כתובת ה-IP של המכונה הווירטואלית.
- ‫PATH_TO_KEY: הנתיב למפתח ה-SSH הפרטי שמתאים למפתח הציבורי שנוצר בשלבים הקודמים.

שימוש ב-RDP כדי לגשת למכונה וירטואלית של Windows

כדי לגשת למכונה וירטואלית של Windows באמצעות פרוטוקול שולחן עבודה מרוחק (RDP) מהרשת המקומית, צריך להפעיל את RDP במערכת ההפעלה של האורח, לוודא שהמכונה הווירטואלית נגישה לרשת ולהגדיר פרטי כניסה של משתמש.

דרישות מוקדמות

הפעלת RDP ב-Windows: צריך להפעיל RDP במערכת ההפעלה האורחת של Windows. אם RDP עדיין לא מופעל, משתמשים במסוף Virtual Network Computing (VNC) כדי לגשת ישירות למסך של ה-VM ולהפעיל אותו. הפקודה kubectl virt vnc פותחת חלון של כלי לצפייה גרפית בתחנת העבודה המקומית, ונדרש לקוח של כלי לצפייה ב-VNC, כמו Remote Viewer או VNC Viewer, שמותקן בתחנת העבודה:

kubectl virt vnc VM_NAME -n NAMESPACE

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

‫VM_NAME: השם של מכונת ה-Windows הווירטואלית.
‫NAMESPACE: מרחב השמות של המכונה הווירטואלית.

התחברות באמצעות RDP

כדי לקבל את כתובת ה-IP של המכונה הווירטואלית, מריצים את הפקודה kubectl get:
```
kubectl get vmi VM_NAME -n NAMESPACE -o jsonpath='{.status.interfaces[*].ipAddress}'
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫VM_NAME: השם של מכונת ה-Windows הווירטואלית.
- ‫NAMESPACE: מרחב השמות של המכונה הווירטואלית.
חשוב לשים לב לכתובת ה-IP ששייכת לתת-הרשת המנותבת מהפלט.
משתמשים בלקוח RDP רגיל, כמו 'חיבור לשולחן עבודה מרוחק' ב-Windows או Remmina ב-Linux, כדי להתחבר לכתובת ה-IP שאוחזרה ביציאה 3389.
משתמשים בשם המשתמש ובסיסמה כדי להיכנס לחשבון.

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

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

הפעלת מכונה וירטואלית: kubectl virt start vmVM_NAME-nNAMESPACE
הפעלה מחדש של מכונה וירטואלית: kubectl virt restart vmVM_NAME-nNAMESPACE
הפסקת מכונה וירטואלית: kubectl virt stop vmVM_NAME-nNAMESPACE

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

‫VM_NAME: השם של המכונה הווירטואלית של היעד.
‫NAMESPACE: מרחב השמות של היעד.

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

נכנסים לדף Clusters במסוף Google Cloud .
מעבר אל Clusters
בוחרים את פרויקט היעד Google Cloud .
(אופציונלי) אם עדיין לא עשיתם זאת, נכנסים לאשכול היעד:
1. בחלונית הניווט הימנית, לוחצים על Clusters (אשכולות).
2. ברשימה Anthos Managed Clusters (אשכולות מנוהלים של Anthos), לוחצים על אשכול היעד.
3. בחלונית המידע בצד שמאל, לוחצים על כניסה.
4. בתיבת הדו-שיח שמופיעה, בוחרים את שיטת האימות המועדפת, מזינים את פרטי הכניסה ולוחצים על כניסה.
עוברים לדף Virtual Machines.
מעבר אל Virtual Machines
ברשימת המכונות הווירטואליות, מסמנים את התיבות של המכונות הווירטואליות הרצויות.
בראש הדף, לוחצים על התחלה או על הפסקה, בהתאם לצורך.

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

נכנסים לדף Clusters במסוף Google Cloud .
מעבר אל Clusters
בוחרים את פרויקט היעד Google Cloud .
(אופציונלי) אם עדיין לא עשיתם זאת, נכנסים לאשכול היעד:
1. בחלונית הניווט הימנית, לוחצים על Clusters (אשכולות).
2. ברשימה Anthos Managed Clusters (אשכולות מנוהלים של Anthos), לוחצים על אשכול היעד.
3. בחלונית המידע בצד שמאל, לוחצים על כניסה.
4. בתיבת הדו-שיח הקופצת שמופיעה, בוחרים את שיטת האימות המועדפת, מזינים את פרטי הכניסה ולוחצים על כניסה.
עוברים לדף Virtual Machines.
מעבר אל Virtual Machines
לוחצים על המכונה הווירטואלית של היעד.
בדף שמופיע, לוחצים על הכרטיסיות פרטים, אירועים ו-YAML כדי לראות את המידע הרלוונטי על המכונה הווירטואלית הזו.

שינוי מכונה וירטואלית

כדי לשנות מכונה וירטואלית, צריך למחוק אותה וליצור אותה מחדש עם ההגדרה המעודכנת.

מחיקת מכונה וירטואלית באמצעות מסוף Google Cloud

נכנסים לדף Clusters במסוף Google Cloud .
מעבר אל Clusters
בוחרים את פרויקט היעד Google Cloud .
(אופציונלי) אם עדיין לא עשיתם זאת, נכנסים לאשכול היעד:
1. בחלונית הניווט הימנית, לוחצים על Clusters (אשכולות).
2. ברשימה Anthos Managed Clusters (אשכולות מנוהלים של Anthos), לוחצים על אשכול היעד.
3. בחלונית המידע בצד שמאל, לוחצים על כניסה.
4. בתיבת הדו-שיח שמופיעה, בוחרים את שיטת האימות המועדפת, מזינים את פרטי הכניסה ולוחצים על כניסה.
עוברים לדף מכונות וירטואליות.
מעבר אל Virtual Machines
ברשימת המכונות הווירטואליות, מסמנים את התיבה של המכונה הווירטואלית הרצויה.
בחלק העליון של הדף, לוחצים על מחיקה.
בתיבת הדו-שיח לאישור שמופיעה, מזינים את השם של המכונה הווירטואלית ולוחצים על מחיקה.

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

הגדרת Symcloud Storage

התקנה של כלי הניהול virtctl

יצירת קטגוריה של Cloud Storage לקובצי אימג' של מכונות וירטואליות

הגבלת הגישה לקטגוריה באמצעות תנאי IAM

יצירת דיסק של מכונה וירטואלית מקובץ אימג' של מכונה וירטואלית

יצירת דיסק מקובץ אימג' שמאוחסן ב-Cloud Storage

יצירת דיסק מתמונה שמאוחסנת בשירות של צד שלישי

יצירת דיסק ריק

הגדרת רשתות וירטואליות

יצירת מכונה וירטואלית

יצירת מכונה וירטואלית באמצעות Google Cloud המסוף

יצירת מכונה וירטואלית מקובץ YAML

יצירת מכונה וירטואלית מקובץ אימג' של דיסק שאפשר לאתחל ממנו

שימוש ב-cloud-init API כדי להפעיל מכונות וירטואליות

אוטומציה של הגדרת מכונות וירטואליות באמצעות cloud-init נתוני משתמש

פתרון בעיות cloud-init

יצירת מכונה וירטואלית מקובץ אימג' של דיסק אופטי ISO

יצירת קובצי המניפסט

יצירת הדיסקים

יצירת מכונה וירטואלית של Windows

מתחברים ומשלימים את ההתקנה

גישה באמצעות פרוטוקול Remote Desktop

יצירת מכונה וירטואלית עם תמיכה ב-GPU

מפרט מכונה וירטואלית

גישה למכונה וירטואלית

דרישות הרשת לגישה ישירה

קבלת פרטי כניסה למכונות וירטואליות של Linux

שימוש ב-RDP כדי לגשת למכונה וירטואלית של Windows

דרישות מוקדמות

התחברות באמצעות RDP

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

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

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

שינוי מכונה וירטואלית

מחיקת מכונה וירטואלית באמצעות מסוף Google Cloud

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

ניהול מכונות וירטואליות

התקנה של כלי הניהול `virtctl`

שימוש ב-`cloud-init` API כדי להפעיל מכונות וירטואליות

אוטומציה של הגדרת מכונות וירטואליות באמצעות `cloud-init` נתוני משתמש

פתרון בעיות `cloud-init`