Cluster Anthos on bare metal kini menjadi Google Distributed Cloud (khusus software) untuk bare metal. Untuk mengetahui informasi selengkapnya, lihat ringkasan produk.

Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat dan menggunakan jaringan virtual untuk Runtime VM di GDC

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

Sebelum memulai

Untuk menyelesaikan dokumen ini, Anda memerlukan akses ke resource berikut:

Akses ke cluster Google Distributed Cloud versi 1.12.0 (anthosBareMetalVersion: 1.12.0) atau yang lebih tinggi. Anda dapat menggunakan jenis cluster apa pun yang dapat menjalankan beban kerja. Jika diperlukan, coba Google Distributed Cloud di Compute Engine atau lihat ringkasan pembuatan cluster.
Alat klien virtctl yang diinstal sebagai plugin untuk kubectl. Jika diperlukan, instal alat klien virtctl.

Ringkasan jaringan virtual

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

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

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

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 diisi secara otomatis. Konfigurasi DNS menggunakan nilai yang sama dengan cluster.

pod-network dapat digunakan oleh workload 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 workload, 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 workload VM Anda menentukan apakah pod-network default ini sudah memadai, 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 butuhkan, seperti penggunaan server DHCP eksternal atau penggunaan ID VLAN. Jaringan ini menyediakan konektivitas lapisan 2 (L2) untuk VM Anda.

Menggunakan server DHCP eksternal

Runtime VM 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 node Google Distributed Cloud tempat jaringan akan dilampirkan. Tentukan nama antarmuka fisik di node yang akan digunakan. Semua node di cluster Anda harus memiliki nama antarmuka yang sama.
Dalam manifes Network ini, nilai berikut ditetapkan:
- type disetel ke L2. Dengan setelan ini, workload 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. Setelan ini mengaktifkan DHCP eksternal untuk jaringan. Server DHCP eksternal bertanggung jawab atas konfigurasi alamat IPv4, rute, gateway, dan 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

Runtime VM 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 node Google Distributed Cloud tempat jaringan akan dilampirkan. Tentukan nama antarmuka fisik di node yang akan digunakan. Semua node di cluster Anda harus memiliki nama antarmuka yang sama.
- ROUTE_ADDRESS: rute opsional dalam notasi CIDR untuk dikonfigurasi di 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 yang akan digunakan VM Anda.
Simpan dan tutup manifes Network di editor Anda.
Buat jaringan menggunakan kubectl:
```
kubectl apply -f manual-network.yaml
```

Menggunakan 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. Di 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 node Google Distributed Cloud tempat jaringan akan dilampirkan. Tentukan nama antarmuka fisik di node yang akan digunakan. Semua node di cluster Anda harus memiliki nama antarmuka yang sama.
- VLAN_ID: ID VLAN yang ingin Anda beri tag pada traffic.
Dalam manifes Network ini, nilai berikut ditetapkan:
- Workload 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 telah membuat, antarmuka VLAN di node, tetapkan nilai networkLifecycle ke UserManaged seperti yang ditunjukkan di bagian berikutnya.
- Jaringan telah mengaktifkan DHCP eksternal. Server DHCP eksternal bertanggung jawab atas konfigurasi alokasi alamat, rute, gateway, dan DNS IPv4 untuk workload 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

Dalam contoh jaringan virtual berikut, jaringan dikelola pengguna, bukan dikelola Anthos dalam contoh sebelumnya. Di 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 tempat jaringan dipasang.
- VLAN_ID: ID VLAN yang ingin Anda beri tag pada traffic.
Dalam manifes Network ini, nilai berikut ditetapkan:
- Workload 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 konfigurasi alokasi alamat, rute, gateway, dan DNS IPv4 untuk workload 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 opsi konfigurasi jaringan tertentu ditentukan:

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 otomatis mendapatkan penetapan alamat IP. 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 konten file ini untuk melihat definisi resource Kubernetes yang dibuat oleh Runtime VM 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 ini, 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.
Disk booting bernama VM_NAME-boot-dv harus sudah ada. Untuk mengetahui informasi selengkapnya, lihat Membuat disk booting VM.
Simpan dan tutup manifes VirtualMachine di editor Anda.
Buat VM menggunakan kubectl:
```
kubectl apply -f my-vm.yaml
```

Langkah selanjutnya

Mengedit VM di Google Distributed Cloud.