Menyiapkan Pengarahan Layanan

Halaman ini menunjukkan cara menyiapkan Pengarahan Layanan untuk Pod Anda.

Untuk memahami cara kerja Pengarahan Layanan, lihat Cara kerja Pengarahan Layanan.

Persyaratan

  • GKE versi 1.30 atau yang lebih baru.

Batasan

  • ServiceFunctionChain dapat memiliki maksimal satu Fungsi Layanan.
  • Sebaiknya gunakan maksimum 100 node ditambah 10 pasangan ServiceFunctionChain dan TrafficSelector.
  • Pengarahan Layanan GKE hanya tersedia dengan node yang menjalankan image node Container-Optimized OS.
  • Pengarahan Layanan GKE hanya mendukung alamat IP tujuan dan keluar.
  • Pengarahan Layanan tidak menangani konflik yang muncul saat beberapa Pemilih Traffic dengan panjang awalan yang identik diterapkan ke subjek yang sama. Untuk menghindari konflik, desain Pemilih Traffic Anda secara proaktif dengan rentang alamat IP yang tidak tumpang-tindih dan kriteria pemilihan yang ditentukan dengan jelas.

Menerapkan Pengarahan Layanan

Pengarahan Layanan GKE memungkinkan Anda menyesuaikan dan mengontrol alur traffic jaringan dalam cluster. Bagian ini menunjukkan cara menerapkan Pengarahan Layanan menggunakan contoh Gateway web.

Pertimbangkan kasus penggunaan saat Anda ingin membuat Gateway web yang mengamankan traffic dari perangkat klien pengguna akhir ke internet. Terminator VPN menarik traffic ke Gateway terkelola menggunakan tunnel yang aman. Traffic pengguna akhir dialihkan ke firewall, lalu ke proxy. Proxy melakukan Penafsiran Alamat Jaringan Sumber (SNAT) pada traffic, menyamarkan alamat sumber asli, dan mengirimkannya ke internet.

Untuk menerapkan Pengarahan Layanan GKE, lakukan hal berikut:

  1. Buat VPC dengan MTU 8896.
  2. Membuat cluster GKE.
  3. Buat Pod dan Layanan Fungsi Layanan.
  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.
    • 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 gcloud components update.

Menyiapkan VPC

Siapkan VPC. Pengarahan Layanan menggunakan enkapsulasi untuk mengalihkan traffic ke Fungsi Layanan yang sesuai. Enkapsulasi melibatkan penambahan header tambahan ke setiap paket, yang meningkatkan ukuran paket. Pengarahan Layanan tidak memerlukan konfigurasi khusus di VPC. Saat menyiapkan VPC, sebaiknya saat memutuskan ukuran MTU, Anda memperhitungkan overhead enkapsulasi. Untuk mengetahui 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 perutean jaringan lanjutan dan pengelolaan alamat IP yang diperlukan untuk menerapkan Pengarahan Layanan di GKE, buat cluster GKE yang mendukung 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 1.30 atau yang lebih baru. Anda juga dapat menggunakan flag --release-channel untuk memilih saluran rilis. Saluran rilis harus memiliki versi default 1.30 atau yang lebih baru.

Membuat Pod ServiceFunction

Untuk membuat Rantai Layanan, deploy Pod terminator VPN dan Pod Fungsi Layanan yang diperlukan dalam cluster Anda. Pod merangkum aplikasi dalam container yang menjalankan fungsi jaringan Anda.

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

File konfigurasi contoh berikut menentukan tiga komponen berikut yang penting untuk pengelolaan traffic jaringan dalam cluster:

  • Pod VPN: membuat 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 memberikan keamanan dan load balancing.
  • Proxy DaemonSet: Men-deploy Pod proxy di setiap node cluster Anda, memastikan traffic jaringan dapat diproses secara lokal sebelum diteruskan ke layanan lain seperti firewall.

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

Buat ServiceFunctionChains

Untuk menentukan urutan fungsi jaringan yang akan dilalui traffic, buat pipeline dengan setiap fungsi seperti firewall, proxy, dan load balancer melakukan tugas tertentu sebelum meneruskan traffic ke fungsi 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 Pengarahan Layanan, buat resource TrafficSelector yang mereferensikan ServiceFunctionChains untuk diterapkan ke 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 Pengarahan Layanan GKE.

Traffic jaringan tidak mengalir

Anda dapat melakukan tindakan berikut untuk men-debug masalah:

Langkah 1: Pastikan servicePathId disetel di ServiceFunctionChain

Pastikan servicePathId disetel di ServiceFunctionChain. Setiap objek ServiceFunctionChain diberi servicePathId unik seperti yang ditunjukkan dalam 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 Layanan Kubernetes dibuat per Fungsi Layanan

Layanan ClusterIP dibuat untuk setiap Fungsi Layanan secara otomatis. Anda dapat melihat 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 Fungsi Layanan, entri peta bpf dibuat di setiap node untuk menyimpan alamat IP Layanan

Untuk setiap Fungsi Layanan, entri peta bpf dibuat di 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 port 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 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 enkapsulasi Geneve di port UDP 7081. Anda dapat menggunakan tcpdump di node yang relevan untuk menganalisis alur traffic dan menentukan lokasi terjadinya masalah.

Langkah berikutnya