Tutorial: Membuat dan mengelola VM Linux dalam Runtime VM di GDC

Tutorial ini menunjukkan cara membuat dan mengelola virtual machine (VM) Linux pada penginstalan baru Runtime VM di GDC. Anda akan mempelajari proses untuk membuat dan menentukan dependensi dasar seperti StorageClass dan jaringan virtual, lalu membuat VM yang menggunakan resource ini. Anda kemudian mempelajari cara mengedit VM, seperti menambahkan disk baru.

Tujuan

Mengonfigurasi dependensi dasar
- Membuat StorageClass untuk Runtime VM di GDC
- Buat jaringan virtual untuk digunakan VM Anda
Membuat boot disk virtual machine
Membuat VM
Mengedit VM untuk menambahkan disk virtual baru

Sebelum memulai

Untuk menyelesaikan tutorial ini, Anda memerlukan akses ke resource dan alat berikut:

Akses ke GKE pada Bare Metal versi 1.12.0 (anthosBareMetalVersion: 1.12.0) atau cluster yang lebih tinggi. Anda dapat menggunakan jenis cluster apa pun yang mampu menjalankan beban kerja. Jika perlu, coba GDCV untuk Bare Metal di Compute Engine atau lihat ringkasan pembuatan cluster.
Alat klien virtctl diinstal sebagai plugin untuk kubectl. Jika perlu, instal alat klien virtctl.

Membuat `StorageClass`

Anda menggunakan StorageClass untuk menentukan jenis penyimpanan yang disediakan untuk VM. Kelas penyimpanan yang berbeda mungkin dipetakan ke jenis hardware penyimpanan, sistem file, atau performa yang berbeda.

Di luar cakupan tutorial ini, petunjuk spesifik yang diberikan kepada setiap StorageClass dan partner penyimpanan tidak termasuk dalam cakupan tutorial ini.

Partner penyimpanan Anthos Ready menyediakan driver Container Storage Interface (CSI) yang memenuhi syarat yang menginstal dan mengonfigurasi resource kustom yang diperlukan untuk penyimpanan Anda. Untuk menginstal driver CSI di cluster Anda, tinjau daftar partner penyimpanan yang didukung dan ikuti petunjuknya.

Setelah menginstal driver CSI untuk platform penyimpanan, satu atau beberapa kelas penyimpanan akan tersedia di cluster Anda. Dalam tutorial ini, Anda akan menggunakan salah satu kelas penyimpanan berikut untuk membuat hard disk virtual.

Contoh dasar berikut NFS StorageClass menggunakan Driver NFS CSI. Anda menentukan alamat server NFS dan jalur yang akan digunakan di StorageClass. Semua node dalam cluster Anda kemudian dapat terhubung ke dan menggunakan penyimpanan NFS ini:

  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

Dalam tutorial ini, gunakan nama StorageClass di cluster Anda sendiri.

Runtime VM di GDC otomatis menghasilkan satu profil penyimpanan untuk setiap StorageClass dalam cluster. Profil penyimpanannya sama dengan nama StorageClass yang terkait. Profil penyimpanan menyediakan opsi konfigurasi tambahan yang terkait dengan setiap StorageClass. Untuk informasi selengkapnya tentang profil penyimpanan, termasuk petunjuk konfigurasi, lihat Mengonfigurasi profil penyimpanan.

Membuat jaringan virtual

VM terhubung ke jaringan virtual menggunakan antarmuka jaringan virtual. Jaringan virtual memungkinkan komunikasi dengan VM lain di dalam cluster atau ke resource di luar cluster.

Dalam tutorial ini, Anda akan membuat jaringan virtual Lapisan 2 (L2) dasar yang dapat menggunakan server DHCP eksternal. Saat mengaktifkan penggunaan server DHCP eksternal, Anda dapat melewati konfigurasi setelan DNS dan gateway jika disediakan oleh DHCP.

Untuk membuat jaringan yang menggunakan server DHCP eksternal, selesaikan langkah-langkah berikut:

Buat manifes Network, seperti dhcp-network.yaml, di editor pilihan Anda:
```
nano dhcp-network.yaml
```
Salin dan tempel manifes YAML berikut:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Ganti nilai berikut:
- NETWORK_NAME: nama untuk jaringan Anda.
- INTERFACE_NAME: nama antarmuka di GKE pada node Bare Metal untuk tempat pemasangan jaringan. Semua node harus memiliki nama antarmuka yang sama.
Dalam manifes Network ini, nilai-nilai berikut telah disetel:
- Beban kerja hanya dapat memiliki lampiran L2 ke jaringan ini. Ini adalah satu-satunya jaringan type yang dapat Anda buat di Runtime VM di GDC.
- Jaringan telah mengaktifkan DHCP eksternal. Server DHCP eksternal bertanggung jawab atas alokasi alamat IPv4, rute, gateway, dan konfigurasi DNS untuk beban kerja yang terhubung ke jaringan ini.
Simpan dan tutup manifes Network di editor Anda.
Buat jaringan menggunakan kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Membuat boot disk VM

VM dapat menggunakan disk image yang telah dibuat sebelumnya, atau booting dari image ISO untuk menginstal OS secara manual. Disk image ini dapat disimpan dan diakses menggunakan HTTP, atau di Cloud Storage dan diakses menggunakan Secret.

Dalam tutorial ini, Anda akan membuat boot disk dari image cloud Ubuntu Server 20.04 publik menggunakan HTTP.

Untuk membuat disk dari image, selesaikan langkah-langkah berikut.

Buat manifes VirtualMachineDisk, seperti my-disk.yaml, di editor pilihan Anda:
```
nano my-disk.yaml
```
Salin dan tempel definisi YAML berikut:
```
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
```
Ganti nilai berikut:
- DISK_NAME: nama yang Anda inginkan untuk disk. Contoh ini akan membuat disk 20Gi (20 gibibyte) yang bernama DISK_NAME menggunakan image Server Ubuntu 20.04 publik.
- STORAGE_CLASS_NAME: StorageClass yang ingin Anda gunakan untuk VirtualMachineDisk.
  - Gunakan kubectl get storageclass untuk membuat daftar apa yang tersedia di cluster Anda.
Catatan: Perlu waktu 15–20 menit untuk mendownload image publik ini, membuat VirtualMachineDisk, dan menerapkan OS image ke disk baru. Proses pembuatan VirtualMachineDisk akan jauh lebih cepat jika Anda menggunakan gambar yang disimpan secara lokal. Untuk sebagian besar skenario produksi, gunakan repositori gambar HTTP lokal, bukan ambil dari sumber publik eksternal setiap saat.
Simpan dan tutup manifes VirtualMachineDisk di editor Anda.
Buat disk menggunakan kubectl:
```
kubectl apply -f my-disk.yaml
```

Membuat VM

Dengan jaringan virtual dan boot disk yang dibuat di bagian sebelumnya, sekarang buatlah VM. VM terhubung ke jaringan virtual, dan melakukan booting dari disk virtual. Petunjuk berikut membuat VM dengan langsung menerapkan file manifes YAML VirtualMachine dengan CLI kubectl.

Buat manifes yang menentukan VirtualMachine, seperti my-vm.yaml, di editor pilihan Anda:
```
nano my-vm.yaml
```
Salin dan tempel definisi YAML berikut:
```
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
```
Ganti nilai berikut:
- VM_NAME: nama untuk VM Anda.
- VCPU_NUMBER: Jumlah vCPU opsional yang akan ditetapkan ke VM. Tanpa setelan ini, 2 vCPU akan ditetapkan secara default.
  - Anda dapat menetapkan antara 1 hingga 96 vCPU ke VM.
- MEMORY_SIZE: Jumlah memori opsional yang akan ditetapkan ke VM. Tanpa setelan ini, memori default 4 GiB akan ditetapkan.
  - Anda dapat menetapkan memori antara 1 juta hingga 1 T untuk VM. Untuk mengetahui informasi selengkapnya, lihat Unit resource memori.
- NETWORK_NAME: nama jaringan Anda yang dibuat di bagian sebelumnya.
- DISK_NAME: nama boot disk Anda yang dibuat di bagian sebelumnya. Disk ini disetel ke boot: true.
Simpan dan tutup manifes di editor Anda.
Buat VM dan disk menggunakan kubectl:
```
kubectl apply -f my-vm.yaml
```
Pembuatan VM ini memerlukan waktu beberapa menit. Periksa status VM dengan perintah kubectl:
```
kubectl get gvm VM_NAME
```
Contoh output berikut menampilkan VM dalam status Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Menghubungkan ke VM

Saat VM Anda berjalan, hubungkan ke konsol VM. Koneksi konsol ini memungkinkan Anda melakukan tugas-tugas dasar seperti mengonfigurasi VM lebih lanjut atau menginstal aplikasi.

Untuk mengakses VM dari konsol, gunakan kubectl:
```
kubectl virt ssh VM_NAME
```
Setelah Anda berhasil terhubung ke konsol VM, keluar dari sesi dan konsol VM:
```
Ctrl + ]
```

Mengedit VM

Selama siklus proses VM, Anda mungkin perlu mengedit VM. Misalnya, Anda mungkin ingin menambahkan penyimpanan untuk menginstal aplikasi di disk khusus, atau menggunakan penyimpanan tambahan untuk aplikasi Anda.

Dalam tutorial ini, buat disk kosong dan lampirkan ke VM. Skenario ini memungkinkan Anda membuat disk data untuk menyimpan data aplikasi.

Buat manifes VirtualMachineDisk, seperti my-data-disk.yaml, di editor pilihan Anda:
```
nano my-data-disk.yaml
```
Salin dan tempel definisi YAML berikut:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Ganti nilai berikut:
- DATA_DISK_NAME: nama yang Anda inginkan untuk disk data Anda. Contoh ini akan membuat disk 10Gi (10 gibibyte).
- STORAGE_CLASS_NAME: StorageClass yang ingin Anda gunakan untuk VirtualMachineDisk.
  - Gunakan kubectl get storageclass untuk membuat daftar apa yang tersedia di cluster Anda.
Simpan dan tutup manifes disk di editor Anda.
Buat disk menggunakan kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Gunakan kubectl untuk menghentikan VM sebelum Anda memasang disk virtual baru:
```
kubectl virt stop VM_NAME
```

Edit resource VM Anda:

kubectl edit gvm VM_NAME

Perbarui manifes YAML VirtualMachine untuk memasang disk di akhir bagian 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

Ganti DATA_DISK_NAME dengan nama disk yang dibuat di langkah sebelumnya.

Simpan dan tutup manifes VM yang diupdate di editor Anda.
Gunakan kubectl untuk memulai VM:
```
kubectl virt start VM_NAME
```

Pembersihan

Untuk menghapus resource yang dibuat dalam tutorial ini, selesaikan langkah-langkah berikut:

Hapus VM Anda:
```
kubectl delete -f my-vm.yaml
```

Hapus resource VirtualMachineDisk Anda:

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

Jika Anda tidak ingin mempertahankan dependensi dasar di cluster, selesaikan langkah-langkah berikut:

Hapus jaringan virtual Anda:

kubectl delete -f use-dhcp-network.yaml

Untuk menghapus driver CSI dari cluster, ikuti petunjuk dari partner penyimpanan Anda.