הדרכה: יצירה וניהול של מכונה וירטואלית של Linux ב-VM Runtime ב-GDC

במדריך הזה תלמדו איך ליצור ולנהל מכונה וירטואלית (VM) של Linux בהתקנה חדשה של VM Runtime ב-GDC. במדריך הזה תלמדו איך ליצור ולהגדיר את התלות הבסיסית, כמו StorageClass ורשת וירטואלית, ואז ליצור מכונה וירטואלית שמשתמשת במשאבים האלה. אחר כך תלמדו איך לערוך את מכונת ה-VM, למשל כדי להוסיף דיסק חדש.

מטרות

הגדרת יחסי תלות בסיסיים
- יצירת StorageClass ל-VM Runtime ב-GDC
- יצירת רשת וירטואלית לשימוש במכונות וירטואליות
יצירת דיסק אתחול של מכונה וירטואלית
יצירת VM
עריכת מכונה וירטואלית כדי להוסיף דיסק וירטואלי חדש

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

כדי להשלים את המדריך הזה, תצטרכו גישה למשאבים ולכלים הבאים:

גישה ל-Google Distributed Cloud מגרסה 1.12.0‏ (anthosBareMetalVersion: 1.12.0) ואילך של אשכול. אפשר להשתמש בכל סוג של אשכול שיכול להריץ עומסי עבודה. אם צריך, אפשר לנסות את Google Distributed Cloud ב-Compute Engine או לעיין בסקירה הכללית על יצירת אשכולות.
כלי הלקוח virtctl מותקן כפלאגין של kubectl. במקרה הצורך, מתקינים את כלי הלקוח virtctl.

יצירת `StorageClass`

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

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

שותפי אחסון שעומדים בדרישות של Google Distributed Cloud מספקים מנהלי התקנים מוסמכים של Container Storage Interface‏ (CSI) שמתקינים ומגדירים את המשאבים המותאמים אישית הנדרשים לאחסון שלכם. כדי להתקין את מנהל ה-CSI באשכול, צריך לעיין ברשימת שותפי האחסון הנתמכים ולפעול לפי ההוראות שלהם.

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

בדוגמה הבסיסית הבאה של NFS StorageClass נעשה שימוש ב-NFS CSI Driver. מגדירים את הכתובת של שרת NFS ואת הנתיב לשימוש ב-StorageClass. כל הצמתים באשכול יכולים להתחבר לאחסון NFS הזה ולהשתמש בו:

  apiVersion: storage.k8s.io/v1
  kind: StorageClass
  metadata:
    name: example-nfs
  provisioner: nfs.csi.k8s.io
  parameters:
    server: nfs-server.example.com
    path: /vm-share
  reclaimPolicy: Delete
  volumeBindingMode: Immediate
  mountOptions:
    - nconnect=8
    - nfsvers=4.1

במדריך הזה, משתמשים בשם של StorageClass באשכול שלכם.

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

יצירת רשת וירטואלית

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

במדריך הזה יוצרים רשת וירטואלית בסיסית בשכבה 2 (L2) שיכולה להשתמש בשרת DHCP חיצוני. כשמפעילים את השימוש בשרת DHCP חיצוני, אפשר לדלג על הגדרת ה-DNS והשער אם הם מסופקים על ידי DHCP.

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

יוצרים מניפסט Network, כמו dhcp-network.yaml, בכלי העריכה שבוחרים:
```
nano dhcp-network.yaml
```
מעתיקים ומדביקים את קובץ המניפסט הבא בפורמט YAML:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
מחליפים את הערכים הבאים:
- ‫NETWORK_NAME: השם של הרשת.
- ‫INTERFACE_NAME: שם הממשק בצומת Google Distributed Cloud שאליו רוצים לצרף את הרשת. לכל הצמתים צריך להיות אותו שם ממשק.
בNetwork קובץ המניפסט הזה, הערכים הבאים מוגדרים:
- עומסי עבודה יכולים לכלול רק L2 מצורף לרשת הזו. זו הרשת היחידה type שאפשר ליצור ב-VM Runtime ב-GDC.
- ברשת מופעל DHCP חיצוני. שרת ה-DHCP החיצוני אחראי להקצאת כתובות IPv4, מסלולים, שער ותצורת DNS לעומסי עבודה שמחוברים לרשת הזו.
שומרים וסוגרים את קובץ המניפסט Network בכלי העריכה.
יוצרים את הרשת באמצעות kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

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

מכונה וירטואלית יכולה להשתמש בקובץ אימג' של דיסק שנוצר מראש, או לבצע אתחול מקובץ אימג' ISO כדי להתקין את מערכת ההפעלה באופן ידני. אפשר לאחסן את תמונות הדיסק האלה ולגשת אליהן באמצעות HTTP, או ב-Cloud Storage ולגשת אליהן באמצעות Secret.

במדריך הזה יוצרים דיסק אתחול מתמונת הענן הציבורית של Ubuntu Server 20.04 באמצעות HTTP.

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

יוצרים קובץ VirtualMachineDisk manifest, כמו my-disk.yaml, בכלי העריכה הרצוי:
```
nano my-disk.yaml
```
מעתיקים ומדביקים את הגדרת ה-YAML הבאה:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 20Gi
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
מחליפים את הערכים הבאים:
- DISK_NAME: השם שרוצים לתת לדיסק. בדוגמה הזו נוצר דיסק בגודל 20Gi (20 גיביבייט) בשם DISK_NAME באמצעות תמונה ציבורית של Ubuntu Server 20.04.
- ‫STORAGE_CLASS_NAME: StorageClass שרוצים להשתמש בו ב-VirtualMachineDisk.
  - משתמשים בפקודה kubectl get storageclass כדי לראות מה זמין באשכול.
הערה: יכולות לעבור 15 עד 20 דקות עד שהתמונה הציבורית הזו תרד, עד שייווצר ה-VirtualMachineDisk ועד שתמונת מערכת ההפעלה תוחל על הדיסק החדש. התהליך ליצירת VirtualMachineDisk מהיר הרבה יותר כשמשתמשים בתמונה שמאוחסנת באופן מקומי. ברוב תרחישי הייצור, מומלץ להשתמש במאגר תמונות HTTP מקומי במקום לשלוף ממקור חיצוני ציבורי בכל פעם.
שומרים וסוגרים את קובץ המניפסט VirtualMachineDisk בכלי העריכה.
יוצרים את הדיסק באמצעות kubectl:
```
kubectl apply -f my-disk.yaml
```

יצירת VM

אחרי שיצרתם רשת וירטואלית ודיסק אתחול כמו שמוסבר בקטעים הקודמים, עכשיו יוצרים מכונה וירטואלית. המכונה הווירטואלית מתחברת לרשת הווירטואלית ומבצעת אתחול מהדיסק הווירטואלי. ההוראות הבאות יוצרות מכונה וירטואלית על ידי החלה ישירה של קובץ מניפסט YAML‏ VirtualMachine באמצעות ה-CLI‏ kubectl.

יוצרים מניפסט שמגדיר VirtualMachine, כמו my-vm.yaml, בכלי העריכה הרצוי:
```
nano my-vm.yaml
```
מעתיקים ומדביקים את הגדרת ה-YAML הבאה:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  osType: linux
  compute:
    cpu:
      vcpus: VCPU_NUMBER
    memory:
      capacity: MEMORY_SIZE
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
```
מחליפים את הערכים הבאים:
- ‫VM_NAME: השם של ה-VM.
- ‫VCPU_NUMBER: מספר ה-vCPU האופציונלי להקצאה למכונה הווירטואלית. אם לא מגדירים את ההגדרה הזו, מוקצים 2 מעבדים וירטואליים כברירת מחדל.
  - אפשר להקצות למכונה וירטואלית בין 1 ל-96 מעבדים וירטואליים.
- ‫MEMORY_SIZE: כמות הזיכרון האופציונלית להקצאה למכונה הווירטואלית. אם לא מגדירים את ההגדרה הזו, מוקצה זיכרון של 4GiB כברירת מחדל.
  - אפשר להקצות ל-VM זיכרון בנפח של 1M עד 1T. מידע נוסף זמין במאמר יחידות משאבי זיכרון.
- ‫NETWORK_NAME: השם של הרשת שיצרתם בקטע הקודם.
- ‫DISK_NAME: השם של דיסק האתחול שנוצר בקטע הקודם. הכונן הזה מוגדר לboot: true.
שומרים את המניפסט וסוגרים אותו בכלי העריכה.
יוצרים את המכונה הווירטואלית והדיסק באמצעות kubectl:
```
kubectl apply -f my-vm.yaml
```
יכול להיות שיחלפו כמה דקות עד שהמכונה הווירטואלית תיווצר. בודקים את הסטטוס של ה-VM באמצעות פקודת kubectl:
```
kubectl get gvm VM_NAME
```
בדוגמה הבאה של הפלט אפשר לראות שהמכונה הווירטואלית במצב Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

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

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

כדי לגשת למכונה וירטואלית מהמסוף, משתמשים ב-kubectl:
```
kubectl virt console VM_NAME
```
כשמוצגת בקשה, מזינים את פרטי הכניסה של המשתמש שציינתם כדי ליצור את המכונה הווירטואלית.
אחרי שמתחברים בהצלחה למסוף של המכונה הווירטואלית, יוצאים מהסשן של המכונה הווירטואלית ומהמסוף:
```
Ctrl + ]
```

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

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

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

יוצרים קובץ VirtualMachineDisk manifest, כמו my-data-disk.yaml, בכלי העריכה הרצוי:
```
nano my-data-disk.yaml
```
מעתיקים ומדביקים את הגדרת ה-YAML הבאה:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
מחליפים את הערכים הבאים:
- ‫DATA_DISK_NAME: השם שרוצים לתת לדיסק הנתונים. בדוגמה הזו נוצר דיסק 10Gi (10 גיביבייט).
- ‫STORAGE_CLASS_NAME: StorageClass שרוצים להשתמש בו ב-VirtualMachineDisk.
  - משתמשים בפקודה kubectl get storageclass כדי לראות מה זמין באשכול.
שומרים את מניפסט הדיסק וסוגרים את העורך.
יוצרים את הדיסק באמצעות kubectl:
```
kubectl apply -f my-data-disk.yaml
```
משתמשים בפקודה kubectl כדי לעצור את המכונה הווירטואלית לפני שמצרפים את הדיסק הווירטואלי החדש:
```
kubectl virt stop VM_NAME
```
עורכים את משאב המכונה הווירטואלית:
```
kubectl edit gvm VM_NAME
```
מעדכנים את מניפסט ה-YAML‏ VirtualMachine כדי לצרף את הדיסק בסוף הקטע spec.disks של ה-VM:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  ...
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
    - virtualMachineDiskName: DATA_DISK_NAME
```
מחליפים את DATA_DISK_NAME בשם הדיסק שיצרתם בשלב הקודם.
שומרים וסוגרים את מניפסט מכונת ה-VM המעודכן בעורך.
משתמשים ב-kubectl כדי להפעיל את המכונה הווירטואלית:
```
kubectl virt start VM_NAME
```

הסרת המשאבים

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

מחיקת המכונה הווירטואלית:
```
kubectl delete -f my-vm.yaml
```

מחיקת משאבים ב-VirtualMachineDisk:

kubectl delete -f my-data-disk.yaml
kubectl delete -f my-disk.yaml

אם אתם לא רוצים לשמור את התלויות הבסיסיות באשכול, אתם צריכים לבצע את השלבים הבאים:

מחיקת הרשת הווירטואלית:

kubectl delete -f use-dhcp-network.yaml

כדי להסיר את מנהל ה-CSI מהאשכול, פועלים לפי ההוראות של שותף האחסון.