Configura il reindirizzamento dei servizi

Questa pagina mostra come configurare il reindirizzamento dei servizi per i pod.

Per capire come funziona l'indirizzamento del servizio, vedi Come funziona l'indirizzamento del servizio.

Requisiti

  • GKE versione 1.30 o successive.

Limitazioni

  • Un ServiceFunctionChain può avere al massimo una funzione di servizio.
  • Consigliamo un massimo di 100 nodi più 10 ServiceFunctionChain e TrafficSelector coppie.
  • La gestione dei servizi GKE è disponibile solo con i nodi che eseguono l'immagine del nodo Container-Optimized OS.
  • Il Reindirizzamento servizio di GKE supporta solo il traffico in uscita e l'IP di destinazione indirizzi IP esterni.
  • Il Reindirizzamento servizio non gestisce i conflitti che si verificano quando più traffico Allo stesso soggetto vengono applicati dei selettori con prefissi di lunghezza identica. 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 dei servizi

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 il Service Steering utilizzando un esempio di gateway web.

Considera 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 indirizza il traffico nel gateway gestito utilizzando un tunnel sicuro. Il traffico dell'utente finale viene reindirizzato al firewall e poi al proxy. Il proxy esegue l'indirizzo di rete di origine La traduzione (SNAT) del traffico, maschera l'indirizzo di origine originale e invia a internet.

Per implementare il reindirizzamento servizio di GKE, svolgi i seguenti passaggi:

  1. Crea un VPC con un MTU di 8896.
  2. Creare un cluster GKE.
  3. Creare i pod e il servizio della funzione di servizio.
  4. Crea il ServiceFunctionChain.
  5. Crea la risorsa TrafficSelector facendo 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à, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.

Prezzi

Le seguenti funzionalità di Network Function Optimizer (NFO) sono supportate solo su cluster che si trovano all'interno di progetti in cui è abilitato GKE Enterprise:

Per comprendere le tariffe applicate per l'abilitazione della versione Google Kubernetes Engine (GKE) Enterprise, consulta Prezzi di GKE Enterprise.

Preparare un VPC

Prepara un VPC. Service Steering utilizza l'incapsulamento per reindirizzare il traffico alle funzioni di servizio appropriate. L'incapsulamento prevede l'aggiunta di intestazioni aggiuntive a ciascun pacchetto. aumentando così le dimensioni del pacchetto. Service Steering non richiede una configurazione speciale nei VPC. Durante la preparazione della VPC, ti consigliamo di tenere conto dell'overhead di incapsulamento quando decidi le dimensioni dell'MTU. Per ulteriori informazioni, vedi 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 contenente la subnet.

Crea un cluster GKE

Abilitare le funzionalità avanzate di routing di rete e di gestione degli indirizzi IP necessarie per implementare il Reindirizzamento servizio su GKE, creazione un cluster GKE abilitato per GKE Dataplane V2 come segue:

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 GKE, che deve 1.30 o versioni successive. Puoi anche utilizzare il flag --release-channel per selezionare un canale di rilascio. Il canale di rilascio deve avere una versione predefinita pari o successiva a 1.30.

Crea ServiceFunction pod

Per stabilire la catena di servizi, esegui il deployment del pod di terminazione VPN 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 di terminazione VPN è 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 seguenti 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 tuo cluster, che consente la 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 per fornire sicurezza e bilanciamento del carico.
  • DaemonSet proxy: esegue il deployment di un pod proxy su ogni nodo del cluster, assicurando 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 per il traffico da attraversare, crea una pipeline in cui ogni funzione, come firewall, proxy e bilanciatore del carico, esegua la propria attività specifica 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 vengono definite in linea all'interno di ServiceFunctionChain utilizzando nel campo serviceFunctions. Una funzione di servizio è un selettore di endpoint.

Crea la risorsa TrafficSelector

Per definire dove e quale traffico viene selezionato per il Reindirizzamento servizio, crea il TrafficSelector risorsa che fa riferimento al ServiceFunctionChains da applicare a per il 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 dei servizi

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

Il traffico di rete non scorre

Per eseguire il debug del problema, puoi procedere nel seguente modo:

Passaggio 1: verifica che servicePathId sia impostato su ServiceFunctionChain

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

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 in base alla funzione di servizio

Per ogni funzione di servizio viene creato automaticamente un servizio ClusterIP. Puoi visualizza 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 della mappa bpf su ogni nodo per memorizzare l'indirizzo IP del servizio

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

Ottieni 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

Su un nodo, se sono presenti pod selezionati da un TrafficSelector, le voci di mappa bpf vengono create 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 Geneva sulla porta UDP 7081. Puoi utilizzare tcpdump sui nodi pertinenti per analizzare il flusso di traffico e individuare il punto in cui potrebbe verificarsi il problema.

Passaggi successivi