Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat dan menggunakan jaringan virtual untuk Runtime VM di GDC

Dokumen ini ditujukan untuk spesialis Admin IT, Operator, dan Jaringan yang menjalankan GKE di Bare Metal. Dokumen ini menunjukkan cara membuat dan menggunakan jaringan virtual untuk mendukung workload VM yang menggunakan VM Runtime di GDC. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami rujuk dalam konten Google Cloud, lihat Peran dan tugas pengguna GKE Enterprise umum.

Sebelum memulai

Untuk menyelesaikan dokumen ini, Anda memerlukan akses ke referensi 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 GKE di Bare Metal di Compute Engine atau lihat ringkasan pembuatan cluster.
Alat klien virtctl diinstal sebagai plugin untuk kubectl. Jika perlu, instal alat klien virtctl.

Ringkasan jaringan virtual

Jaringan dibuat menggunakan resource kustom. Jaringan dapat dibuat kapan saja setelah cluster dibuat. Setelan jaringan untuk antarmuka host dan penetapan ID VLAN, jika ditentukan, tidak dapat diubah setelah Anda membuat jaringan.

Penghapusan jaringan tunduk pada beberapa ketentuan. Misalnya, pengontrol jaringan menolak penghapusan jaringan saat digunakan oleh resource apa pun, seperti VM atau antarmuka jaringan.

Definisi jaringan dapat mencakup gateway, rute, dan informasi DNS. Anda juga dapat mengaktifkan penggunaan server DHCP eksternal. Setelan jaringan ini ditetapkan secara statis atau dinamis, bergantung pada cara penentuan opsi konfigurasi jaringan tertentu.

Jaringan pod default

Setiap cluster memiliki pod-network yang dibuat secara default untuk Anda. Jaringan ini tidak dapat diubah. Rute untuk CIDR pod dan CIDR layanan, serta konfigurasi DNS akan otomatis diisi. Konfigurasi DNS menggunakan nilai yang sama dengan cluster.

pod-network dapat digunakan oleh beban kerja yang memerlukan antarmuka untuk mengakses jaringan pod cluster dan tidak memerlukan opsi konfigurasi tertentu. Rute pod-network selalu dikonfigurasi untuk memastikan akses cluster dan layanan untuk beban kerja, meskipun gateway default tidak berada di antarmuka pod-network.

pod-network default ini memungkinkan Anda menguji Runtime VM di GDC tanpa langkah tambahan untuk membuat jaringan virtual Anda sendiri. Banyak dokumen kami menggunakan pod-network default ini untuk mengurangi kompleksitas contoh. Kebutuhan beban kerja VM Anda menentukan apakah pod-network default ini sudah cukup, atau apakah Anda perlu membuat dan menggunakan jaringan virtual Anda sendiri.

Manifes YAML berikut menunjukkan contoh konfigurasi untuk pod-network. Nilai untuk rute, DNS, dan nama antarmuka telah diisi oleh cluster:

  apiVersion: networking.gke.io/v1
  kind: Network
  metadata:
    name: pod-network
  spec:
    routes:
    - to: 192.168.0.0/16
    - to: 10.96.0.0/12
    dnsConfig:
      nameservers:
      - 10.96.0.10

Membuat dan menggunakan jaringan virtual

Untuk mendukung beban kerja produksi, buat jaringan yang mendukung fitur yang Anda perlukan, seperti penggunaan server DHCP eksternal atau penggunaan ID VLAN. Jaringan-jaringan ini menyediakan konektivitas lapisan 2 (L2) untuk VM Anda.

Menggunakan server DHCP eksternal

VM Runtime di GDC tidak menyediakan server DHCP. Anda harus menentukan alamat IP untuk VM secara manual atau mengonfigurasi penggunaan 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 use-dhcp-network.yaml, di editor pilihan Anda:
```
nano use-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. Tentukan nama antarmuka fisik pada node yang akan digunakan. Semua node dalam cluster Anda harus memiliki nama antarmuka yang sama.
Dalam manifes Network ini, nilai-nilai berikut telah disetel:
- type disetel ke L2. Dengan setelan ini, beban kerja hanya dapat memiliki lampiran Lapisan 2 ke jaringan ini. Ini adalah satu-satunya type jaringan yang dapat Anda buat di Runtime VM di GDC.
- externalDHCP4 disetel ke true. Pengaturan ini memungkinkan DHCP eksternal untuk jaringan. Server DHCP eksternal bertanggung jawab atas alokasi alamat, 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
```

Menentukan setelan jaringan secara manual

VM Runtime di GDC tidak menyediakan server DHCP. Anda harus menentukan alamat IP untuk VM secara manual atau mengonfigurasi penggunaan server DHCP eksternal. Jika menentukan alamat IP secara manual, Anda harus menentukan setelan jaringan untuk DNS, rute, dan gateway default.

Untuk membuat jaringan dengan setelan jaringan yang ditentukan secara manual untuk VM, selesaikan langkah-langkah berikut:

Buat manifes Network, seperti manual-network.yaml, di editor pilihan Anda:
```
nano manual-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
  routes:
  - to: "ROUTE_ADDRESS"
  gateway4: GATEWAY_ADDRESS
  dnsConfig:
    nameservers:
    - NAMESERVER_ADDRESS
```
Ganti nilai berikut:
- NETWORK_NAME: nama untuk jaringan Anda.
- INTERFACE_NAME: nama antarmuka di GKE pada node Bare Metal untuk tempat pemasangan jaringan. Tentukan nama antarmuka fisik pada node yang akan digunakan. Semua node dalam cluster Anda harus memiliki nama antarmuka yang sama.
- ROUTE_ADDRESS: rute opsional dalam notasi CIDR untuk mengonfigurasi pada setiap VM yang terhubung ke jaringan ini.
- GATEWAY_ADDRESS: alamat IP gateway yang akan digunakan VM Anda.
- NAMESERVER_ADDRESS: satu atau beberapa alamat IP server nama DNS untuk digunakan oleh VM Anda.
Simpan dan tutup manifes Network di editor Anda.
Buat jaringan menggunakan kubectl:
```
kubectl apply -f manual-network.yaml
```

Gunakan ID VLAN

Saat membuat jaringan virtual, Anda dapat menentukan VLAN yang diberi tag. Penetapan VLAN ini membantu Anda mengisolasi traffic jaringan berdasarkan persyaratan workload dan kebutuhan isolasi. Dalam jaringan AnthosManaged, cluster memiliki izin untuk membuat dan menghapus antarmuka VLAN di setiap node.

Untuk membuat jaringan yang menentukan penetapan VLAN, selesaikan langkah-langkah berikut:

Buat manifes Network, seperti vlan-network.yaml, di editor pilihan Anda:
```
nano vlan-network.yaml
```
Salin dan tempel manifes YAML berikut:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  networkLifecycle: AnthosManaged
  l2NetworkConfig:
    vlanID: VLAN_ID
  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. Tentukan nama antarmuka fisik pada node yang akan digunakan. Semua node dalam cluster Anda harus memiliki nama antarmuka yang sama.
- VLAN_ID: ID VLAN yang ingin Anda beri tag traffic.
Dalam manifes Network ini, nilai-nilai berikut telah disetel:
- Beban kerja hanya dapat memiliki lampiran L2 ke jaringan ini.
- Jaringannya adalah AnthosManaged. Setelan ini adalah siklus proses default jika tidak ditentukan.
  - Dalam mode ini, cluster memiliki izin untuk membuat dan menghapus antarmuka VLAN di setiap node, seperti INTERFACE_NAME.VLAN_ID.
  - Jika Anda ingin membuat atau sudah membuatnya, VLAN antarmuka pada node, tetapkan nilai networkLifecycle ke UserManaged seperti yang ditunjukkan di bagian berikutnya.
- 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 vlan-network.yaml
```

Membuat jaringan yang dikelola pengguna

Pada contoh jaringan virtual berikut, jaringan dikelola pengguna, berbeda dengan dikelola Anthos di contoh sebelumnya. Dalam jaringan yang dikelola pengguna, Anda bertanggung jawab untuk membuat atau menghapus antarmuka VLAN di host.

Untuk membuat jaringan dalam mode yang dikelola pengguna dan menentukan konfigurasi antarmuka VLAN secara manual, selesaikan langkah-langkah berikut:

Buat manifes Network, seperti user-managed-network.yaml, di editor pilihan Anda:
```
nano user-managed-network.yaml
```
Salin dan tempel definisi YAML berikut:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  networkLifecycle: UserManaged
  l2NetworkConfig:
    vlanID: VLAN_ID
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Ganti nilai berikut:
- NETWORK_NAME: nama untuk jaringan Anda.
- INTERFACE_NAME: antarmuka host untuk memasang jaringan.
- VLAN_ID: ID VLAN yang ingin Anda beri tag traffic.
Dalam manifes Network ini, nilai-nilai berikut telah disetel:
- Beban kerja hanya dapat memiliki lampiran L2 ke jaringan ini.
- Jaringannya adalah UserManaged. Anda harus membuat atau menghapus antarmuka VLAN_ID VLAN di setiap node sebelum jaringan dibuat, atau setelah jaringan dihapus.
- 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 user-managed-network.yaml

Menghubungkan VM ke jaringan

Setelan jaringan untuk VM Anda, seperti DNS dan DHCP, ditetapkan secara statis atau dinamis, bergantung pada cara menentukan opsi konfigurasi jaringan tertentu:

Jika Anda mengonfigurasi alamat IP statis di VM, tidak ada kueri yang dikirim ke server DHCP. Informasi tambahan untuk mengonfigurasi gateway dan rute harus berasal dari resource jaringan.
Jika Anda tidak mengonfigurasi alamat IP statis di VM, kueri akan dikirim ke server DHCP. VM mendapatkan semua informasi dari server DHCP dan mengabaikan konfigurasi apa pun yang Anda tentukan di resource jaringan.
Jika DHCP eksternal tidak ditetapkan ke true di resource jaringan, Anda harus mengonfigurasi alamat IP statis untuk VM. Semua informasi lainnya berasal dari konfigurasi yang Anda tentukan di resource jaringan.

Untuk membuat VM yang terhubung ke jaringan, selesaikan langkah-langkah berikut:

CLI

Untuk membuat VM menggunakan kubectl, selesaikan langkah-langkah berikut:
```
kubectl virt create vm VM_NAME \
  --image ubuntu20.04 \
  --network NETWORK_NAME
```
Ganti nilai berikut:
- VM_NAME: nama untuk VM Anda.
- NETWORK_NAME: nama jaringan yang akan dihubungkan.
  - Jika jaringan dikonfigurasi untuk mengizinkan penggunaan server DHCP eksternal, VM akan mendapatkan penetapan alamat IP secara otomatis. Jika Anda perlu menentukan alamat IP statis, tambahkan parameter dan nilai --ip IP_ADDRESS opsional.
Catatan: Di direktori ~/google-virtctl, file VM_NAME.yaml akan dibuat. Anda dapat melihat isi file ini untuk melihat definisi resource Kubernetes yang dibuat oleh VM Runtime di GDC.

Manifes

Untuk membuat VM menggunakan manifes YAML, selesaikan langkah-langkah berikut:

Buat manifes VirtualMachine, seperti my-vm.yaml, di editor pilihan Anda:
```
nano my-vm.yaml
```
Salin dan tempel manifes YAML berikut:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      ipAddresses:
        - IP_ADDRESS
      default: true
  disks:
    - virtualMachineDiskName: VM_NAME-boot-dv
      boot: true
```
Dalam manifes YAML, tentukan setelan berikut:
- VM_NAME: nama untuk VM Anda.
- NETWORK_NAME: nama jaringan yang akan dihubungkan.
- IP_ADDRESS: alamat IP dalam notasi CIDR untuk ditetapkan ke VM Anda, seperti 192.0.2.10/24.
  - Jika jaringan Anda dikonfigurasi untuk mengizinkan penggunaan server DHCP eksternal, hapus kolom ini dari manifes VirtualMachine.
Boot disk dengan nama VM_NAME-boot-dv harus sudah ada. Untuk mengetahui informasi selengkapnya, lihat Membuat boot disk VM.
Simpan dan tutup manifes VirtualMachine di editor Anda.
Buat VM menggunakan kubectl:
```
kubectl apply -f my-vm.yaml
```

Langkah selanjutnya

Mengedit VM di GKE di Bare Metal.