Halaman ini diterjemahkan oleh Cloud Translation API.

Mengonfigurasi Multus dengan IPVLAN dan Whereabouts

Standard

Dokumen ini menjelaskan cara mengonfigurasi Pod di Google Kubernetes Engine (GKE) dengan beberapa antarmuka jaringan menggunakan Multus CNI, plugin IPVLAN CNI, dan plugin IPAM Whereabouts.

Plugin CNI IPVLAN menyediakan konektivitas Lapisan 2 untuk antarmuka Pod tambahan, dan plugin IPAM Whereabouts secara dinamis menetapkan alamat IP untuk antarmuka tersebut.

Penyiapan ini memungkinkan konfigurasi jaringan lanjutan, seperti memisahkan traffic bidang kontrol dan bidang data untuk isolasi dan segmentasi jaringan yang lebih baik.

Dokumen ini ditujukan bagi arsitek Cloud dan spesialis Jaringan yang mendesain dan membangun arsitektur jaringan untuk organisasi mereka. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam konten Google Cloud , lihat Peran dan tugas pengguna GKE umum.

Sebelum membaca dokumen ini, pastikan Anda memahami konsep berikut:

Manfaat menggunakan Multus dengan IPVLAN

Mengonfigurasi Pod dengan beberapa antarmuka jaringan menggunakan solusi ini memberikan beberapa keuntungan utama. Kasus penggunaan utama untuk mengonfigurasi Multus dengan IPVLAN dalam mode Lapisan 2 adalah untuk segmentasi jaringan yang memerlukan kedekatan Lapisan 2:

Isolasi traffic: mengisolasi berbagai jenis traffic untuk meningkatkan keamanan dan performa. Misalnya, Anda dapat memisahkan traffic pengelolaan yang sensitif dari traffic data aplikasi.
Pemisahan bidang kontrol dan bidang data: mengkhususkan antarmuka jaringan utama untuk traffic bidang kontrol sekaligus mengarahkan traffic bidang data dengan throughput tinggi melalui antarmuka IPVLAN sekunder.
Adjacency Lapisan 2: memenuhi persyaratan untuk aplikasi yang memerlukan konektivitas Lapisan 2 langsung antara Pod di jaringan sekunder yang sama.

Batasan

Pod yang dikonfigurasi dengan antarmuka Multus tidak dapat menggunakan kemampuan multi-jaringan bawaan GKE secara bersamaan. Konfigurasi jaringan Pod harus menggunakan Multus atau multi-jaringan bawaan cluster.

Cara kerja Multus dengan IPVLAN dan Whereabouts

Multus adalah plugin meta CNI yang memungkinkan Pod terhubung ke beberapa jaringan. Multus bertindak sebagai dispatcher, memanggil plugin CNI lain untuk mengonfigurasi antarmuka jaringan berdasarkan resource NetworkAttachmentDefinition. Anda menentukan setiap jaringan tambahan dengan menggunakan NetworkAttachmentDefinition, yang menentukan plugin CNI (seperti IPVLAN) dan plugin IPAM (seperti Whereabouts) yang akan digunakan untuk jaringan tersebut.

Diagram berikut menggambarkan arsitektur Multus dengan plugin IPVLAN dan Whereabouts.Plugin Whereabouts berfungsi dengan Multus dan IPVLAN untuk menangani pengelolaan alamat IP (IPAM) untuk antarmuka jaringan tambahan Pod.

Diagram yang menunjukkan cara Multus, IPVLAN, dan Whereabouts bekerja sama di GKE. — Gambar 1. Arsitektur Multus dengan plugin IPVLAN dan Whereabouts.

Saat menggunakan Multus dengan IPVLAN dan Whereabouts di GKE, Pod biasanya memiliki konfigurasi antarmuka berikut:

Antarmuka utama (eth0): GKE Dataplane V2 mengelola antarmuka ini, yang menyediakan konektivitas cluster default.
Antarmuka tambahan (net1, dll.): Multus mengelola antarmuka ini. Multus memanggil plugin CNI IPVLAN dalam mode Layer 2 untuk setiap NetworkAttachmentDefinition yang Anda tentukan dalam anotasi Pod. Konfigurasi ini menyediakan konektivitas Lapisan 2 ke jaringan VPC sekunder.
Pengelolaan Alamat IP (IPAM): Anda mengonfigurasi plugin IPAM Whereabouts dalam NetworkAttachmentDefinition. Plugin Whereabouts IPAM secara dinamis menetapkan alamat IP ke antarmuka IPVLAN tambahan dari rentang yang telah ditentukan sebelumnya.

Penjadwalan Pod dengan beberapa jaringan

Saat Anda membuat Pod dan menentukan NetworkAttachmentDefinition dalam anotasinya, penjadwal GKE hanya menempatkan Pod di node yang dapat memenuhi persyaratan jaringan. Scheduler mengidentifikasi node dalam kumpulan node yang telah mengonfigurasi antarmuka jaringan sekunder yang diperlukan. Proses identifikasi node ini memastikan bahwa penjadwal menjadwalkan Pod di node yang dapat terhubung ke jaringan tambahan dan menerima alamat IP dari rentang yang ditentukan.

Bagian berikut akan memandu Anda mengonfigurasi Multus dengan plugin IPVLAN dan Whereabouts di cluster GKE Anda.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. gcloud CLI versi sebelumnya mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

Instal alat command line kubectl.
Siapkan cluster GKE yang menjalankan versi 1.28 atau yang lebih baru dengan Dataplane V2, IP Alias, dan multi-jaringan yang diaktifkan. Untuk mempelajari caranya, lihat Menyiapkan dukungan multi-jaringan untuk Pod. Mengaktifkan multi-jaringan juga mengaktifkan fitur Kebijakan HA Multi-IP-Subnet dan IP Persisten, yang menghilangkan kebutuhan akan penyiapan konektivitas antar-node secara manual.
Gunakan versi Multus CNI yang divalidasi GKE (seperti v4.2.1) untuk kompatibilitas.

Menyiapkan VPC

Untuk menyiapkan Virtual Private Cloud (VPC) yang akan digunakan dengan Multus, termasuk membuat subnet untuk jaringan node dan rentang sekunder untuk jaringan Pod, selesaikan langkah-langkah berikut:

Buat VPC baru atau gunakan yang sudah ada:
```
gcloud compute networks create VPC_NAME \
--subnet-mode=custom
```
Ganti VPC_NAME dengan nama VPC.
Buat subnet baru dalam VPC ini:
```
gcloud compute networks subnets create SUBNET_NAME \
    --range=PRIMARY_RANGE \
    --network=VPC_NAME \
    --region=REGION \
    --secondary-range=SECONDARY_RANGE_NAME=SECONDARY_RANGE_CIDR
```
Ganti kode berikut:
- SUBNET_NAME: nama subnet baru.
- PRIMARY_RANGE: rentang CIDR utama untuk subnet, seperti 10.0.1.0/24. Perintah ini menggunakan rentang ini untuk antarmuka node.
- VPC_NAME: nama VPC.
- REGION: region untuk subnet, seperti us-central1.
- SECONDARY_RANGE_NAME: nama rentang alamat IP sekunder untuk Pod di subnet.
- SECONDARY_RANGE_CIDR: rentang CIDR sekunder untuk Pod, seperti 172.16.1.0/24. Antarmuka tambahan di Pod menggunakan rentang ini.
Perintah ini membuat subnet dengan rentang CIDR primer untuk antarmuka node tambahan dan rentang sekunder untuk antarmuka Pod tambahan.

Buat cluster Standar GKE

Buat cluster GKE Standard dengan multi-jaringan diaktifkan:

gcloud container clusters create CLUSTER_NAME \
    --cluster-version=CLUSTER_VERSION \
    --enable-dataplane-v2 \
    --enable-ip-alias \
    --enable-multi-networking

Ganti kode berikut:

CLUSTER_NAME: nama cluster baru.
CLUSTER_VERSION: versi cluster GKE Anda. Anda harus menggunakan versi 1.28 atau yang lebih baru.

Dengan mengaktifkan multi-jaringan, Anda dapat membuat node pool dengan beberapa antarmuka jaringan, yang diperlukan oleh Multus CNI.

Membuat node pool GKE Standard

Buat node pool GKE Standard yang terhubung ke jaringan VPC tambahan:

gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME \
    --zone "ZONE" \
    --additional-node-network network=VPC_NAME,subnetwork=SUBNET_NAME \
    --additional-pod-network subnetwork=SUBNET_NAME,pod-ipv4-range=SECONDARY_RANGE_NAME,max-pods-per-node=8

Ganti kode berikut:

NODEPOOL_NAME: nama node pool baru.
CLUSTER_NAME: nama cluster Anda.
ZONE: zona untuk node pool, seperti us-central1-c.
VPC_NAME: nama VPC tambahan.
SUBNET_NAME: nama subnet.
SECONDARY_RANGE_NAME: nama rentang alamat IP sekunder untuk Pod di subnet.

Perintah ini membuat node pool tempat node memiliki antarmuka jaringan tambahan di SUBNET_NAME, dan Pod di node ini dapat menggunakan alamat IP dari SECONDARY_RANGE_NAME.

Untuk mengetahui informasi selengkapnya tentang cara membuat cluster GKE dengan kemampuan multi-jaringan, lihat Menyiapkan dukungan multi-jaringan untuk pod.

Terapkan deployment Multus

Untuk mengaktifkan beberapa antarmuka jaringan untuk Pod, instal plugin CNI Multus. Simpan manifes berikut, yang mencakup DaemonSet dan Custom Resource Definition (CRD) yang diperlukan, sebagai multus-manifest.yaml:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: ippools.whereabouts.cni.cncf.io
spec:
  group: whereabouts.cni.cncf.io
  names:
    kind: IPPool
    listKind: IPPoolList
    plural: ippools
    singular: ippool
  scope: Namespaced
  versions:
  - name: v1alpha1
    schema:
      openAPIV3Schema:
        description: IPPool is the Schema for the ippools API
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation
                of an object. Servers should convert recognized schemas to the latest
                internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
                object represents. Servers may infer this from the endpoint the client
                submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: IPPoolSpec defines the desired state of IPPool
            properties:
              allocations:
                additionalProperties:
                  description: IPAllocation represents metadata about the pod/container
                    owner of a specific IP
                  properties:
                    id:
                      type: string
                    podref:
                      type: string
                  required:
                  - id
                  type: object
                description: Allocations is the set of allocated IPs for the given
                  range. Its indices are a direct mapping to the IP with the same
                  index/offset for the pools range.
                type: object
              range:
                description: Range is a RFC 4632/4291-style string that represents
                  an IP address and prefix length in CIDR notation
                type: string
            required:
            - allocations
            - range
            type: object
        type: object
    served: true
    storage: true
status:
  acceptedNames:
    kind: ""
    plural: ""
  conditions: []
  storedVersions: []
---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.4.1
  name: overlappingrangeipreservations.whereabouts.cni.cncf.io
spec:
  group: whereabouts.cni.cncf.io
  names:
    kind: OverlappingRangeIPReservation
    listKind: OverlappingRangeIPReservationList
    plural: overlappingrangeipreservations
    singular: overlappingrangeipreservation
  scope: Namespaced
  versions:
  - name: v1alpha1
    schema:
      openAPIV3Schema:
        description: OverlappingRangeIPReservation is the Schema for the OverlappingRangeIPReservations
          API
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: OverlappingRangeIPReservationSpec defines the desired state
              of OverlappingRangeIPReservation
            properties:
              containerid:
                type: string
              podref:
                type: string
            required:
            - containerid
            type: object
        required:
        - spec
        type: object
    served: true
    storage: true
status:
  acceptedNames:
    kind: ""
    plural: ""
  conditions: []
  storedVersions: []
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: multus-cni-config
  namespace: kube-system
  labels:
    app: gke-multinet
data:
  cni-conf.json: |
    {
      "name": "multus-cni-network",
      "type": "multus",
      "confDir": "/etc/cni/net.d",
      "namespaceIsolation": true,
      "logLevel": "verbose",
      "logFile": "/var/log/multus.log",
      "kubeconfig": "/var/lib/kubelet/kubeconfig",
      "clusterNetwork": "gke-pod-network"
    }
---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: network-attachment-definitions.k8s.cni.cncf.io
spec:
  group: k8s.cni.cncf.io
  scope: Namespaced
  names:
    plural: network-attachment-definitions
    singular: network-attachment-definition
    kind: NetworkAttachmentDefinition
    shortNames:
    - net-attach-def
  versions:
  - name: v1
    served: true
    storage: true
    schema:
      openAPIV3Schema:
        description: 'NetworkAttachmentDefinition is a CRD schema specified by the Network Plumbing
            Working Group to express the intent for attaching pods to one or more logical or physical
            networks. More information available at: https://github.com/k8snetworkplumbingwg/multi-net-spec'
        type: object
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this represen
                tation of an object. Servers should convert recognized schemas to the
                latest internal value, and may reject unrecognized values. More info:
                https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
                object represents. Servers may infer this from the endpoint the client
                submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: 'NetworkAttachmentDefinition spec defines the desired state of a network attachment'
            type: object
            properties:
              config:
                description: 'NetworkAttachmentDefinition config is a JSON-formatted CNI configuration'
                type: string
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: multus-role
rules:
- apiGroups: ["k8s.cni.cncf.io"]
  resources:
  - '*'
  verbs:
  - '*'
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: whereabouts
rules:
- apiGroups:
  - whereabouts.cni.cncf.io
  resources:
  - ippools
  - overlappingrangeipreservations
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
  - delete
- apiGroups:
  - coordination.k8s.io
  resources:
  - leases
  verbs:
  - create
- apiGroups:
  - coordination.k8s.io
  resources:
  - leases
  resourceNames:
  - whereabouts
  verbs:
  - '*'
- apiGroups: [""]
  resources:
  - pods
  verbs:
  - list
  - get
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: multus-role-binding
subjects:
- kind: Group
  name: system:nodes
roleRef:
  kind: ClusterRole
  name: multus-role
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: whereabouts-role-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: whereabouts
subjects:
- kind: ServiceAccount
  name: whereabouts-sa
  namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: whereabouts-sa
  namespace: kube-system
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: gke-multinet
  namespace: kube-system
  labels:
    app: gke-multinet
spec:
  selector:
    matchLabels:
      app: gke-multinet
  template:
    metadata:
      labels:
        app: gke-multinet
    spec:
      priorityClassName: system-node-critical
      hostNetwork: true
      tolerations:
      - operator: Exists
      serviceAccountName: whereabouts-sa
      containers:
      - name: whereabouts-gc
        command: [/ip-control-loop]
        args:
        - "--log-level=debug"
        - "--enable-pod-watch=false"
        - "--cron-schedule=* * * * *"
        image: gcr.io/gke-release/whereabouts:v0.7.0-gke.3@sha256:2bb8450a99d86c73b262f5ccd8c433d3e3abf17d36ee5c3bf1056a1fe479e8c2
        env:
        - name: NODENAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: spec.nodeName
        - name: WHEREABOUTS_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
      initContainers:
      - name: install-multus-config
        image: gcr.io/gke-release/multus-cni:v4.2.1-gke.6@sha256:25b48b8dbbf6c78a10452836f52dee456514783565b70633a168a39e6d322310
        args:
        - "--cni-conf-dir=/host/etc/cni/net.d"
        - "--multus-conf-file=/tmp/multus-conf/00-multus.conf"
        - "--multus-log-level=verbose"
        - "--multus-kubeconfig-file-host=/var/lib/kubelet/kubeconfig"
        - "--skip-multus-binary-copy=true"
        - "--skip-config-watch=true"
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        volumeMounts:
        - name: cni
          mountPath: /host/etc/cni/net.d
        - name: multus-cfg
          mountPath: /tmp/multus-conf
      - name: install-whereabouts
        command: ["/bin/sh"]
        args:
        - -c
        - >
          SLEEP=false /install-cni.sh
        image: gcr.io/gke-release/whereabouts:v0.7.0-gke.3@sha256:2bb8450a99d86c73b262f5ccd8c433d3e3abf17d36ee5c3bf1056a1fe479e8c2
        env:
        - name: NODENAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: spec.nodeName
        - name: WHEREABOUTS_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        volumeMounts:
        - name: cni
          mountPath: /host/etc/cni/net.d
        - name: cnibin
          mountPath: /host/opt/cni/bin
      - name: install-binary
        image: gcr.io/gke-release/multus-cni:v4.2.1-gke.6@sha256:25b48b8dbbf6c78a10452836f52dee456514783565b70633a168a39e6d322310
        command: ["/gkecmd"]
        args:
        - "-operation=copy"
        - "-cni-bin-dir=/host/opt/cni/bin"
        resources:
          requests:
            cpu: "10m"
            memory: "100Mi"
          limits:
            cpu: "10m"
            memory: "100Mi"
        securityContext:
          privileged: true
        volumeMounts:
        - name: cnibin
          mountPath: /host/opt/cni/bin
      volumes:
      - hostPath:
          path: /var/lib/kubelet/kubeconfig
          type: File
        name: kubelet-credentials
      - name: cni
        hostPath:
          path: /etc/cni/net.d
          type: DirectoryOrCreate
      - name: cnibin
        hostPath:
          path: /home/kubernetes/bin
          type: DirectoryOrCreate
      - name: multus-cfg
        configMap:
          name: multus-cni-config
          items:
          - key: cni-conf.json
            path: 00-multus.conf
  updateStrategy:
    rollingUpdate:
      maxUnavailable: 2
    type: RollingUpdate

Kemudian, terapkan manifes ke cluster Anda:

kubectl apply -f multus-manifest.yaml

Buat manifes `NetworkAttachmentDefinition`

Agar Pod dapat terhubung ke jaringan tambahan, buat manifes NetworkAttachmentDefinition. Manifes ini menentukan cara Pod terhubung ke jaringan dan menentukan rentang alamat IP yang ditetapkan oleh plugin IPAM, seperti Whereabouts. Rentang ini harus menjadi bagian dari subnet yang menghubungkan antarmuka jaringan tambahan node Anda.

Simpan manifes ini sebagai nad.yaml. Manifes ini menggunakan plugin IPVLAN dan Whereabouts.
```
apiVersion: "k8s.cni.cncf.io/v1"
kind: NetworkAttachmentDefinition
metadata:
  name: NAD_NAME
spec:
  config: '{
    "cniVersion": "0.3.1",
    "plugins": [
      {
        "type": "ipvlan",
        "master": "eth1",
        "mode": "l2",
        "ipam": {
          "type": "whereabouts",
          "range": SECONDARY_RANGE_NAME
        }
      }
    ]
  }'
```
Manifes mencakup kolom berikut:
- NAD_NAME: nama NetworkAttachmentDefinition Anda.
- master: nama antarmuka jaringan sekunder node, yang bertindak sebagai antarmuka master untuk IPVLAN. Di GKE, antarmuka jaringan sekunder biasanya dimulai dengan eth1 dan diberi nama secara berurutan. Untuk mengonfirmasi nama antarmuka, hubungkan ke node menggunakan SSH dan jalankan perintah ip addr.
- range: rentang alamat IP untuk antarmuka Pod, yang sama dengan rentang IPv4 sekunder yang Anda buat untuk Pod (SECONDARY_RANGE_NAME). Misalnya, 172.16.1.0/24.
Terapkan manifes ke cluster Anda:
```
kubectl apply -f nad.yaml
```

Menghubungkan Pod ke jaringan tambahan

Untuk melampirkan Pod ke jaringan tambahan, tambahkan anotasi k8s.v1.cni.cncf.io/networks ke manifes Pod. Untuk beberapa jaringan, berikan daftar nama NetworkAttachmentDefinition yang dipisahkan koma dalam format berikut: <namespace>/<nad-name>.

Contoh berikut menunjukkan manifes Pod yang terlampir ke NetworkAttachmentDefinition bernama NAD_NAME di namespace default:

apiVersion: v1
kind: Pod
metadata:
  name: samplepod
  annotations:
    k8s.v1.cni.cncf.io/networks: default/NAD_NAME
spec:
  containers:
  - name: sample-container
    image: nginx

Ganti NAD_NAME dengan nama NetworkAttachmentDefinition yang Anda buat.

Saat Anda menerapkan manifes ini, Kubernetes akan membuat Pod dengan antarmuka jaringan tambahan (net1) yang terhubung ke jaringan yang ditentukan oleh NetworkAttachmentDefinition.

Memverifikasi alamat IP tambahan Pod

Untuk memverifikasi bahwa Pod menerima alamat IP tambahan setelah Anda melampirkan Pod ke jaringan tambahan, periksa antarmuka jaringan dalam Pod:

Untuk memeriksa samplepod dan memverifikasi alamat IP tambahan, gunakan perintah berikut:
```
$kubectl describe pod PODNAME
```
Ganti PODNAME dengan nama Pod Anda, seperti samplepod.

Periksa output-nya. Antarmuka eth0 memiliki alamat IP utama Pod. Plugin Whereabouts menetapkan alamat IP tambahan ke antarmuka lain, seperti net1.

Outputnya mirip dengan hal berikut ini:

k8s.v1.cni.cncf.io/network-status:
  [{
    "name": "gke-pod-network",
    "interface": "eth0",
    "ips": [
      "10.104.3.4"
    ],
    "mac": "ea:e2:f6:ce:18:b5",
    "default": true,
    "dns": {},
    "gateway": [
      "\u003cnil\u003e"
    ]
  },{
    "name": "default/my-nad",
    "interface": "net1",
    "ips": [
      "10.200.1.1"
    ],
    "mac": "42:01:64:c8:c8:07",
    "dns": {}
  }]
k8s.v1.cni.cncf.io/networks: default/my-nad

Dalam contoh ini, 10.104.5.19 adalah alamat IP utama di eth0, dan 10.200.1.1 adalah alamat IP tambahan di net1.

Langkah berikutnya

Pelajari lebih lanjut Multus CNI.
Pelajari lebih lanjut IPVLAN CNI.
Pelajari Whereabouts IPAM lebih lanjut.