Configurare il reindirizzamento dei servizi

Questa pagina mostra come configurare Service Steering per i tuoi pod.

Per capire come funziona Service Steering, consulta Come funziona Service Steering.

Requisiti

  • GKE 1.30 o versioni successive.

Limitazioni

  • Un ServiceFunctionChain può avere al massimo una funzione di servizio.
  • Consigliamo un massimo di 100 nodi più 10 coppie ServiceFunctionChain e TrafficSelector.
  • GKE Service Steering è disponibile solo con i nodi che eseguono l'immagine del nodo Container-Optimized OS.
  • GKE Service Steering supporta solo gli indirizzi IP di uscita e di destinazione.
  • Service Steering non gestisce i conflitti che si verificano quando più selettori di traffico con lunghezze del prefisso identiche vengono applicati allo stesso soggetto. Per evitare conflitti, progetta in modo proattivo i selettori di traffico con intervalli di indirizzi IP non sovrapposti e criteri di selezione chiaramente definiti.

Implementare il reindirizzamento servizio

Il Reindirizzamento servizio di GKE ti consente di personalizzare e controllare il flusso di traffico di rete all'interno di un cluster. Questa sezione mostra come implementare Service Steering utilizzando un esempio di gateway web.

Prendi in considerazione un caso d'uso in cui vuoi creare un gateway web che protegga il traffico dai dispositivi client degli utenti finali a internet. Un terminatore VPN attira il traffico nel gateway gestito utilizzando un tunnel sicuro. Il traffico degli utenti finali viene reindirizzato al firewall e poi al proxy. Il proxy esegue la Network Address Translation dell'origine (SNAT) sul traffico, maschera l'indirizzo di origine originale e lo invia a internet.

Per implementare il Reindirizzamento servizio di GKE, procedi nel seguente modo:

  1. Crea un VPC con MTU di 8896.
  2. Creare un cluster GKE.
  3. Crea i pod e il servizio di funzione di servizio.
  4. Crea il ServiceFunctionChain.
  5. Crea la risorsa TrafficSelector che fa riferimento a ServiceFunctionChain.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

Prepara un VPC

Prepara un VPC. Service Steering utilizza l'incapsulamento per reindirizzare il traffico alle Service Function appropriate. L'incapsulamento comporta l'aggiunta di intestazioni aggiuntive a ogni pacchetto, il che aumenta le dimensioni del pacchetto. Service Steering non richiede una configurazione speciale nei VPC. Durante la preparazione del VPC, ti consigliamo di tenere conto dell'overhead di incapsulamento quando decidi le dimensioni dell'MTU. Per saperne di più, consulta Rete VPC con una MTU specificata.

Il seguente comando imposta la dimensione MTU nel VPC:

gcloud compute networks create VPC_NETWORK_NAME --mtu=8896

Sostituisci VPC_NETWORK_NAME con il nome della rete VPC che contiene la subnet.

Crea un cluster GKE

Per abilitare le funzionalità avanzate di gestione dell'indirizzamento di rete e degli indirizzi IP necessarie per implementare Service Steering su GKE, crea un cluster GKE con GKE Dataplane V2 abilitato nel seguente modo:

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

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del cluster.
  • VPC_NAME: il nome del VPC a cui vuoi associare il cluster.
  • RELEASE_CHANNEL: il nome del canale di rilascio.
  • VERSION: la versione di GKE, che deve essere 1.30 o successive. Puoi anche utilizzare il flag --release-channel per selezionare un canale di rilascio. Il canale di rilascio deve avere una versione predefinita 1.30 o successive.

Crea ServiceFunction pod

Per stabilire la Service Chain, esegui il deployment del pod VPN terminator e dei pod di funzione di servizio necessari all'interno del cluster. I pod incapsulano le applicazioni containerizzate che eseguono le funzioni di rete.

Il pod VPN terminator è spesso la prima funzione di servizio della catena, che termina il traffico che entra nel cluster tramite la VPN. Quindi indirizza le altre funzioni di servizio, come firewall e bilanciamento del carico, per l'ulteriore elaborazione prima di raggiungere la destinazione finale.

Il seguente file di configurazione di esempio definisce i tre componenti essenziali per la gestione del traffico di rete all'interno di un cluster:

  • Pod VPN:stabilisce un endpoint di rete privata virtuale (VPN) all'interno del cluster, il che consente una comunicazione sicura e criptata tra il cluster e le reti esterne.
  • Deployment del firewall:esegue il deployment di più repliche di un pod firewall, che forniscono sicurezza e bilanciamento del carico.
  • DaemonSet proxy:esegue il deployment di un pod proxy su ogni nodo del cluster, garantendo che il traffico di rete possa essere elaborato localmente prima di essere inoltrato ad altri servizi come il firewall.

Salva il seguente manifest di esempio come 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

Applica il manifest:

kubectl apply -f service_function.yaml

Crea ServiceFunctionChains

Per definire una sequenza di funzioni di rete da attraversare per il traffico, crea una pipeline in cui ogni funzione, come firewall, proxy e bilanciatore del carico, esegue il proprio compito specifico prima di passare il traffico alla successiva.

Salva il seguente manifest di esempio come 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

Applica il manifest:

kubectl apply -f ServiceFunctionChain.yaml

Le funzioni di servizio sono definite inline all'interno di ServiceFunctionChain utilizzando il campo serviceFunctions. Una funzione di servizio è un selettore di endpoint.

Crea la risorsa TrafficSelector

Per definire dove e quale traffico viene selezionato per il Service Steering, crea la risorsa TrafficSelector che fa riferimento a ServiceFunctionChains da applicare al traffico scelto.

Salva il seguente manifest di esempio come 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

Applica il manifest:

kubectl apply -f TrafficSelector.yaml

Risolvere i problemi relativi al reindirizzamento del servizio

Questa sezione mostra come risolvere i problemi relativi al Service Steering di GKE.

Il traffico di rete non scorre

Per eseguire il debug del problema, puoi svolgere le seguenti azioni:

Passaggio 1: verifica che servicePathId sia impostato su ServiceFunctionChain

Verifica che servicePathId sia impostato su ServiceFunctionChain. A ogni oggetto ServiceFunctionChain viene assegnato un servicePathId univoco, come mostrato nell'esempio seguente:

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

Passaggio 2: verifica che venga creato un servizio Kubernetes per ogni funzione di servizio

Per ogni funzione di servizio viene creato automaticamente un servizio ClusterIP. Puoi visualizzare l'elenco dei servizi utilizzando kubectl:

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

Passaggio 3: verifica che per ogni funzione di servizio venga creata una voce di mappa BPF su ogni nodo per memorizzare l'indirizzo IP del servizio

Per ogni funzione di servizio, viene creata una voce della mappa bpf su ogni nodo per memorizzare l'indirizzo IP del servizio.

Recupera il nome del pod anetd:

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

Registra il nome del pod simile a anetd.

Esegui questo comando:

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

Sostituisci ANETD-POD-NAME con il nome del pod anetd.

L'output è simile al seguente:

PATH     SERVICE FUNCTION ADDRESS
(1, 1)   10.4.10.124

Passaggio 4: verifica che le voci della mappa BPF siano create nella mappa sfcselect

In un nodo, se sono selezionati pod da un TrafficSelector, vengono create voci della mappa bpf nella mappa sfcselect. L'esempio seguente mostra che il traffico TCP/UDP da qualsiasi porta dell'endpoint (pod) 3783 all'indirizzo IP di destinazione 10.0.2.12 viene indirizzato a un ServiceFunctionChain.

Esegui questo comando:

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

Sostituisci ANETD-POD-NAME con il nome effettivo del pod anetd nel cluster.

L'output è simile al seguente:

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)

Passaggio 5: utilizza tcpdump sulla porta 7081 per acquisire e analizzare il traffico di rete

Service Steering esegue l'incapsulamento Geneve sulla porta UDP 7081. Puoi utilizzare tcpdump sui nodi pertinenti per analizzare il flusso di traffico e individuare dove potrebbe verificarsi il problema.

Passaggi successivi