Menyiapkan Pengarahan Layanan

Halaman ini menunjukkan cara menyiapkan Service Steering untuk Pod Anda.

Untuk memahami cara kerja Service Steering, lihat Cara kerja Service Steering.

Persyaratan

  • GKE versi 1.30 atau yang lebih baru.

Batasan

  • ServiceFunctionChain dapat memiliki maksimal satu Fungsi Layanan.
  • Sebaiknya gunakan maksimum 100 node plus 10 ServiceFunctionChain dan TrafficSelector pasangan.
  • GKE Service Steering hanya tersedia dengan node yang menjalankan Image node OS yang Dioptimalkan untuk Container.
  • GKE Service Steering hanya mendukung IP keluar dan tujuan untuk alamat internal dan eksternal.
  • Pengarahan Layanan tidak menangani konflik yang timbul saat beberapa Traffic Pemilih dengan panjang awalan yang identik akan diterapkan ke subjek yang sama. Kepada menghindari konflik, desain secara proaktif Pemilih Traffic Anda dengan rentang alamat IP yang tidak tumpang-tindih dan kriteria pemilihan yang didefinisikan dengan jelas.

Menerapkan Pengarahan Layanan

GKE Service Steering memungkinkan Anda menyesuaikan dan mengontrol arus traffic jaringan dalam cluster. Bagian ini menunjukkan cara menerapkan Pengarahan Layanan menggunakan contoh {i>Gateway web<i}.

Pertimbangkan sebuah kasus penggunaan saat Anda ingin membuat Gateway web yang mengamankan traffic dari perangkat klien pengguna akhir ke internet. Terminator VPN menarik traffic ke dalam Gateway terkelola menggunakan tunnel aman. Traffic pengguna akhir dialihkan ke {i>firewall<i} dan kemudian {i>proxy<i}. Proxy menjalankan Alamat Jaringan Sumber Terjemahan (SNAT) pada traffic, menyamarkan alamat sumber asli, dan mengirim menyebarkannya ke internet.

Untuk menerapkan GKE Service Steering, lakukan hal berikut:

  1. Membuat VPC dengan MTU 8896.
  2. Membuat cluster GKE.
  3. Membuat Service Function dan Pod Service.
  4. Buat ServiceFunctionChain.
  5. Buat resource TrafficSelector yang mereferensikan ServiceFunctionChain.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

  • Aktifkan Google Kubernetes Engine API.
    • Mengaktifkan 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 gcloud components update.

Harga

Fitur Network Function Optimizer (NFO) berikut didukung hanya pada cluster yang ada di Project yang diaktifkan dengan GKE Enterprise:

Untuk memahami biaya yang berlaku untuk mengaktifkan edisi Google Kubernetes Engine (GKE) Enterprise, lihat Harga GKE Enterprise.

Menyiapkan VPC

Siapkan VPC. Pengarahan Layanan menggunakan enkapsulasi untuk mengalihkan traffic ke jaringan Fungsi Layanan. Enkapsulasi melibatkan penambahan {i> header<i} ekstra ke setiap paket, yang meningkatkan ukuran paket. Pengarahan Layanan tidak memerlukan konfigurasi deployment di VPC. Sambil menyiapkan VPC, kami sebaiknya saat menentukan ukuran MTU, Anda perlu mempertimbangkan overhead enkapsulasi. Untuk informasi selengkapnya, lihat Jaringan VPC dengan MTU yang ditentukan.

Perintah berikut menetapkan ukuran mtu di VPC Anda:

gcloud compute networks create VPC_NETWORK_NAME --mtu=8896

Ganti VPC_NETWORK_NAME dengan nama Jaringan VPC yang berisi subnet.

Membuat cluster GKE

Untuk mengaktifkan kemampuan pemilihan rute jaringan dan pengelolaan alamat IP lanjutan yang diperlukan untuk menerapkan Pengarahan Layanan di GKE, buat cluster GKE dengan GKE Dataplane V2 sebagai berikut:

gcloud container clusters create CLUSTER_NAME \
    --network VPC_NAME \
    --release-channel RELEASE_CHANNEL \
    --cluster-version CLUSTER_VERSION \
    --enable-dataplane-v2 \
    --enable-ip-alias

Ganti kode berikut:

  • CLUSTER_NAME: nama cluster.
  • VPC_NAME: nama VPC yang ingin Anda kaitkan dengan cluster.
  • RELEASE_CHANNEL: nama saluran rilis.
  • VERSION: versi GKE, yang harus adalah 1,30 atau yang lebih baru. Anda juga dapat menggunakan tanda --release-channel untuk memilih saluran rilis. Saluran rilis harus memiliki versi default 1.30 atau yang lebih baru.

Membuat ServiceFunction Pod

Untuk membangun Rantai Layanan, deploy Pod terminator VPN dan Pod Service Function yang diperlukan dalam cluster Anda. Pod mengenkapsulasi aplikasi dalam container yang menjalankan fungsi jaringan.

Pod terminator VPN sering kali merupakan Fungsi Layanan pertama dalam rantai, yang menghentikan traffic yang memasuki cluster melalui VPN. Ini kemudian mengarahkan Fungsi Layanan lainnya seperti firewall dan load balancing untuk pemrosesan lebih lanjut sebelum mencapai tujuan akhir.

Contoh file konfigurasi berikut menentukan tiga komponen berikut penting untuk pengelolaan traffic jaringan dalam cluster:

  • Pod VPN: menetapkan endpoint Virtual Private Network (VPN) dalam cluster Anda, yang memungkinkan komunikasi yang aman dan terenkripsi antara cluster dan jaringan eksternal.
  • Deployment firewall: Men-deploy beberapa replika Pod firewall, yang keamanan dan load balancing.
  • Proxy DaemonSet: Men-deploy Pod proxy pada setiap node cluster, memastikan bahwa lalu lintas jaringan dapat diproses secara lokal sebelum diteruskan ke layanan lain seperti {i>firewall<i}.

Simpan manifes contoh berikut sebagai service_function.yaml:

apiVersion: v1
kind: Pod
  name: vpn
  namespace: vpn
  labels:
    app: vpn
spec:
  containers:
  -   name: vpn
    image: openvpn
    ports:
    -   containerPort: 51820
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: firewall
  namespace: firewall
spec:
  replicas: 3
  selector:
    matchLabels:
      app: firewall
  template:
    metadata:
      labels:
        app: firewall
    spec:
      containers:
      -   name: firewall
        image: firewall
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: proxy
  namespace: proxy
spec:
  selector:
    matchLabels:
      app: proxy
  template:
    metadata:
      labels:
        app: proxy
    spec:
      containers:
      -   name: proxy
        image: proxy

Terapkan manifes:

kubectl apply -f service_function.yaml

Membuat ServiceFunctionChains

Untuk menentukan urutan fungsi jaringan yang akan dilalui traffic, buat pipeline tempat setiap fungsi, seperti firewall, proxy, dan load balancer, tugas spesifiknya sebelum meneruskan lalu lintas ke yang berikutnya.

Simpan manifes contoh berikut sebagai ServiceFunctionChain.yaml:

apiVersion: networking.gke.io/v1
kind: ServiceFunctionChain
metadata:
  name: firewall
spec:
  sessionAffinity:
    clientIpNoDestination:
      timeoutSeconds: 3600 # 1hr
  serviceFunctions:
  -   name: firewall
    namespace: firewall
    podSelector:
      matchLabels:
        app: firewall
---
apiVersion: networking.gke.io/v1
kind: ServiceFunctionChain
metadata:
  name: proxy
spec:
  sessionAffinity:
    clientIpNoDestination: {}
  serviceFunctions:
  -   name: proxy
    namespace: proxy
    podSelector:
      matchLabels:
        app: proxy

Terapkan manifes:

kubectl apply -f ServiceFunctionChain.yaml

Fungsi Layanan ditentukan secara inline dalam ServiceFunctionChain menggunakan kolom serviceFunctions. Fungsi Layanan adalah pemilih endpoint.

Membuat resource TrafficSelector

Untuk menentukan tempat dan traffic mana yang dipilih untuk Service Steering, buat Resource TrafficSelector yang merujuk ke ServiceFunctionChains untuk diterapkan traffic yang dipilih.

Simpan manifes contoh berikut sebagai TrafficSelector.yaml:

apiVersion: networking.gke.io/v1
kind: TrafficSelector
metadata:
  name: vpn-to-firewall
spec:
  serviceFunctionChain: firewall
  subject:
    pods:
      namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: vpn
      podSelector:
        matchLabels:
          app: vpn
  egress:
    to:
      ipBlock:
        cidr: 0.0.0.0/0
    ports:
    -   allPorts:
        protocol: UDP
    -   allPorts:
        protocol: TCP
---
apiVersion: networking.gke.io/v1
kind: TrafficSelector
metadata:
  name: firewall-to-proxy
spec:
  serviceFunctionChain: proxy
  subject:
    pods:
      namespaceSelector:
        kubernetes.io/metadata.name: firewall
      podSelector:
        app: firewall
  egress:
    to:
      ipBlock:
        cidr: 0.0.0.0/0
    ports:
    -   allPorts:
        protocol: UDP
    -   allPorts:
        protocol: TCP

Terapkan manifes:

kubectl apply -f TrafficSelector.yaml

Memecahkan Masalah Pengarahan Layanan

Bagian ini menunjukkan cara menyelesaikan masalah terkait GKE Pengarahan Layanan.

Traffic jaringan tidak mengalir

Anda dapat melakukan tindakan berikut untuk men-debug masalah:

Langkah 1: Pastikan servicePathId ditetapkan pada ServiceFunctionChain

Pastikan servicePathId ditetapkan pada ServiceFunctionChain. Setiap Objek ServiceFunctionChain diberi servicePathId unik seperti yang ditunjukkan di contoh berikut:

apiVersion: networking.gke.io/v1
kind: ServiceFunctionChain
metadata:
  name: firewall
spec:
  serviceFunctions:
  - name: firewall
    namespace: firewall
    podSelector:
      matchLabels:
        app: firewal
status:
  servicePathId: 1

Langkah 2: Pastikan bahwa Service Kubernetes dibuat sesuai Fungsi Layanan

Layanan ClusterIP dibuat untuk setiap Fungsi Layanan secara otomatis. Anda dapat lihat daftar layanan menggunakan kubectl:

kubectl get svc -A -l networking.gke.io/managed-by=service-steering-controller.gke.io

Langkah 3: Pastikan bahwa untuk setiap Service Function, entri peta bpf telah dibuat di setiap node untuk menyimpan alamat IP Layanan

Untuk setiap Fungsi Layanan, entri peta bpf dibuat pada setiap node untuk menyimpan Alamat IP layanan.

Dapatkan nama Pod anetd:

kubectl get pods -n kube-system -o wide -l k8s-app=cilium

Catat nama Pod yang mirip dengan anetd.

Jalankan perintah berikut:

kubectl -n kube-system exec -it ANETD-POD-NAME -- cilium bpf sfcpath list

Ganti ANETD-POD-NAME dengan nama Pod anetd.

Outputnya mirip dengan hal berikut ini:

PATH     SERVICE FUNCTION ADDRESS
(1, 1)   10.4.10.124

Langkah 4: Pastikan entri peta bpf dibuat di peta sfcselect

Pada node, jika ada Pod yang dipilih oleh TrafficSelector, entri peta bpf dibuat di peta sfcselect. Contoh berikut menunjukkan bahwa traffic TCP/UDP dari porta endpoint (Pod) 3783 ke alamat IP tujuan 10.0.2.12 diarahkan ke ServiceFunctionChain.

Jalankan perintah berikut:

kubectl -n kube-system exec -it ANETD-POD-NAME -- cilium bpf sfcselect list

Ganti ANETD-POD-NAME dengan nama sebenarnya untuk Pod anetd di cluster Anda.

Outputnya mirip dengan hal berikut ini:

SELECTOR                            PATH
3783, egress, 0/TCP, 10.0.2.12/32   /32 (1, 1)
3783, egress, 0/UDP, 10.0.2.12/32   /32 (1, 1)

Langkah 5: Gunakan tcpdump di port 7081 untuk merekam dan menganalisis traffic jaringan

Pengarahan Layanan melakukan Geneve enkapsulasi pada porta UDP 7081. Anda dapat menggunakan {i>tcpdump<i} pada {i>node<i} yang relevan untuk menganalisis arus lalu lintas dan menentukan di mana masalah itu mungkin terjadi.

Langkah selanjutnya