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 admin 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 contohnya yang kami rujuk dalam konten Google Cloud, lihat Peran dan tugas pengguna GKE Enterprise yang umum.

Sebelum memulai

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

Akses ke Google Distributed Cloud versi 1.12.0 (anthosBareMetalVersion: 1.12.0) atau cluster yang lebih tinggi. Anda dapat menggunakan jenis cluster apa pun yang dapat menjalankan workload. Jika diperlukan, coba Google Distributed Cloud di Compute Engine atau lihat ringkasan pembuatan cluster.
Alat klien virtctl 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 dibuat. Pengaturan jaringan untuk antarmuka {i>host<i} 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 Anda, seperti VM atau antarmuka jaringan.

Definisi jaringan dapat mencakup {i>gateway<i}, rute, dan informasi DNS. Anda juga dapat mengaktifkan penggunaan server DHCP eksternal. Setelan jaringan ini ditetapkan secara statis atau dinamis tergantung pada cara menentukan opsi konfigurasi.

Jaringan pod default

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

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

pod-network default ini memungkinkan Anda menguji Runtime VM di GDC tanpa langkah-langkah tambahan untuk membuat jaringan virtual Anda sendiri. Banyak dokumen kami yang menggunakan pod-network default untuk mengurangi kompleksitas contoh. Kebutuhan dari workload VM Anda akan 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 :

  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 kebutuhan Anda, seperti penggunaan server DHCP eksternal atau penggunaan ID VLAN. Ini jaringan menyediakan konektivitas lapisan 2 (L2) untuk VM Anda.

Menggunakan server DHCP eksternal

Runtime VM di GDC tidak menyediakan server DHCP. Anda harus secara manual menentukan alamat IP untuk VM atau mengkonfigurasi penggunaan server DHCP eksternal. Kapan Anda mengaktifkan penggunaan server DHCP eksternal, Anda dapat melewati konfigurasi DNS dan pengaturan {i>gateway<i} jika mereka disediakan oleh DHCP.

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

Membuat 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 untuk menghubungkan jaringan. Tentukan nama antarmuka fisik pada {i>node<i} Anda. Semua node dalam 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 jaringan type yang yang dapat Anda buat di VM Runtime di GDC.
- externalDHCP4 disetel ke true. Pengaturan ini memungkinkan DHCP eksternal untuk jaringan. Server DHCP eksternal bertanggung jawab atas alamat IPv4 alokasi, rute, gateway, dan konfigurasi DNS untuk workload 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 secara manual menentukan alamat IP untuk VM atau mengkonfigurasi penggunaan server DHCP eksternal. Jika Anda menentukan alamat IP secara manual, Anda harus menentukan pengaturan jaringan untuk DNS, default, 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 untuk menghubungkan jaringan. Tentukan nama antarmuka fisik pada {i>node<i} Anda. Semua node dalam cluster Anda harus memiliki nama antarmuka yang sama.
- ROUTE_ADDRESS: rute opsional dalam notasi CIDR ke dikonfigurasi di setiap VM yang terhubung ke jaringan ini.
- GATEWAY_ADDRESS: alamat IP gateway untuk VM Anda gunakan.
- NAMESERVER_ADDRESS: satu atau beberapa IP server nama DNS yang berbeda untuk digunakan oleh VM Anda.
Simpan dan tutup manifes Network di editor Anda.
Buat jaringan menggunakan kubectl:
```
kubectl apply -f manual-network.yaml
```

Menggunakan ID VLAN

Saat Anda membuat jaringan virtual, Anda dapat menentukan VLAN yang diberi tag. VLAN ini penetapan membantu Anda mengisolasi traffic jaringan berdasarkan persyaratan workload Anda dan isolasi. Dalam jaringan AnthosManaged, cluster memiliki izin untuk membuat dan menghapus antarmuka VLAN pada setiap {i>node<i}.

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

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 untuk menghubungkan jaringan. Tentukan nama antarmuka fisik pada {i>node<i} Anda. Semua node dalam 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:
- Beban kerja hanya dapat memiliki L2 lampiran 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 VLAN di setiap node, seperti INTERFACE_NAME.VLAN_ID.
  - Jika Anda ingin membuat, atau sudah membuat, antarmuka VLAN pada node, tetapkan nilai networkLifecycle ke UserManaged seperti yang ditunjukkan di bagian berikutnya.
- Jaringan mengaktifkan DHCP eksternal. Server DHCP eksternal merupakan bertanggung jawab atas alokasi alamat IPv4, rute, {i>gateway<i}, dan DNS Anda. 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, seperti berbeda dengan Anthos-managed di contoh sebelumnya. Dalam jaringan yang dikelola pengguna, Anda bertanggung jawab untuk membuat atau menghapus antarmuka VLAN pada {i>host<i}.

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

Buat manifes Network, seperti user-managed-network.yaml, di 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 ke jaringan.
- VLAN_ID: ID VLAN yang ingin Anda beri tag pada traffic.
Dalam manifes Network ini, nilai berikut ditetapkan:
- Beban kerja hanya dapat memiliki L2 lampiran ke jaringan ini.
- Jaringannya adalah UserManaged. Anda harus membuat atau menghapus VLAN VLAN_ID antarmuka di setiap node sebelumnya jaringan dibuat, atau setelah jaringan dihapus.
- Jaringan mengaktifkan DHCP eksternal. Server DHCP eksternal merupakan bertanggung jawab atas alokasi alamat IPv4, rute, {i>gateway<i}, dan DNS Anda. 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, bersifat statis atau dinamis ditetapkan bergantung pada cara opsi konfigurasi jaringan tertentu ditentukan:

Jika Anda mengonfigurasi alamat IP statis pada VM, tidak ada kueri yang dikirim ke DHCP server tertentu. Informasi tambahan untuk mengonfigurasi gateway dan rute harus disertakan dari resource jaringan.
Jika Anda tidak mengonfigurasi alamat IP statis pada VM, kueri akan dikirim ke server DHCP. VM mengambil semua informasi dari server DHCP dan mengabaikan konfigurasi yang Anda tetapkan dalam resource jaringan.
Jika DHCP eksternal tidak disetel ke true dalam resource jaringan, Anda harus mengonfigurasi alamat IP statis untuk VM. Semua informasi lainnya berasal dari yang Anda tetapkan dalam 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 Anda yang akan dihubungkan tempat mesin terhubung.
  - Jika jaringan dikonfigurasi untuk mengizinkan penggunaan DHCP eksternal server, VM mendapatkan penetapan alamat IP secara otomatis. Jika Anda menentukan alamat IP statis, tambahkan Parameter dan nilai --ip IP_ADDRESS.
Catatan: Dalam direktori ~/google-virtctl, File VM_NAME.yaml telah dibuat. Anda dapat lihat isi file ini untuk mengetahui definisi 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 ini, tentukan setelan berikut:
- VM_NAME: nama untuk VM Anda.
- NETWORK_NAME: nama jaringan Anda yang akan dihubungkan tempat mesin terhubung.
- IP_ADDRESS: alamat IP dalam notasi CIDR menjadi tetapkan ke VM, misalnya 192.0.2.10/24.
  - Jika jaringan Anda dikonfigurasi untuk mengizinkan penggunaan DHCP eksternal server, hapus kolom ini dari manifes VirtualMachine.
Boot disk bernama VM_NAME-boot-dv harus sudah ada. Untuk informasi selengkapnya, lihat Buat boot disk VM.
Simpan dan tutup manifes VirtualMachine di editor Anda.
Buat VM menggunakan kubectl:
```
kubectl apply -f my-vm.yaml
```

Langkah selanjutnya

Edit VM di Google Distributed Cloud.