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 successiva.

Limitazioni

• Un ServiceFunctionChain può avere al massimo una funzione di servizio.
• Consigliamo un massimo di 100 nodi più 10 ServiceFunctionChain e TrafficSelector coppie.
• Il Reindirizzamento servizio GKE è disponibile solo con i nodi che eseguono 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 i selettori con prefissi di lunghezza identica. A evitare conflitti, progetta proattivamente i selettori del traffico con che non si sovrappongano e criteri di selezione definiti.

Implementa il reindirizzamento dei servizi

Il Reindirizzamento servizio di GKE consente di personalizzare e controllare di traffico di rete all'interno di un cluster. Questa sezione illustra come Implementare l'indirizzamento dei servizi 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 carattere di terminazione VPN traccia il traffico nel gateway gestito usando un tunnel sicuro. Il traffico degli utenti finali viene reindirizzato al firewall e quindi 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, segui questi passaggi:

1. Crea un VPC con una 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 che fa riferimento a ServiceFunctionChain.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Attiva l'API Google Kubernetes Engine.
Abilita 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, scarica la versione più recente eseguendo gcloud components update.

• Abilita GKE Enterprise.

• Esamina i requisiti e le limitazioni.

Prezzi

Sono supportate le seguenti funzionalità NFO (Network Function Optimizer) solo sui cluster che si trovano in progetti abilitati con GKE Enterprise

• Supporto di più reti per i pod
• Supporto degli indirizzi IP permanenti per i pod (anteprima)
• Criteri di rete di più reti (anteprima)
• Supporto del Reindirizzamento servizio per i pod (anteprima)

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

prepara un VPC

Prepara un VPC. Il Reindirizzamento servizio utilizza l'incapsulamento per reindirizzare il traffico all'istanza Funzioni di servizio. L'incapsulamento prevede l'aggiunta di intestazioni aggiuntive a ciascun pacchetto. aumentando così le dimensioni del pacchetto. Il Reindirizzamento servizio non richiede configurazione nei VPC. Durante la preparazione del VPC, quando scegli la dimensione della MTU, ti consigliamo di tenere conto dall'overhead dell'incapsulamento. 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 del che contiene 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 una canale di rilascio. Il canale di rilascio deve avere una versione predefinita di 1.30 o successiva.

di Gemini Advanced.

Crea ServiceFunction pod

Per stabilire la catena di servizi, esegui il deployment del pod del terminatore VPN di servizio necessari all'interno del cluster. I pod incapsulano containerizzate che eseguono le tue funzioni di rete.

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

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

• Pod VPN: stabilisce un endpoint VPN (Virtual Private Network) all'interno di per il tuo cluster, il che consente la comunicazione sicura e criptata tra cluster e reti esterne.
• Deployment del firewall: esegue il deployment di più repliche di un pod firewall, che per fornire sicurezza e bilanciamento del carico.
• Proxy DaemonSet:esegue il deployment di un pod proxy su ogni nodo del cluster, assicurando che il traffico di rete possa essere elaborato localmente prima inoltrate 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 che il traffico deve attraversare, crea una pipeline in cui ogni funzione come firewall, proxy e bilanciatore del carico esegue per l'attività specifica prima di passare il traffico a quella 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 all'indirizzamento del servizio

Questa sezione mostra come risolvere i problemi relativi a GKE Reindirizzamento servizio.

Flusso di traffico di rete assente

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

Passaggio 1: verifica che servicePathId sia impostato su ServiceFunctionChain

Verifica che servicePathId sia impostato su ServiceFunctionChain. Ogni evento A ServiceFunctionChain è assegnato un servicePathId univoco, come mostrato in 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 in base alla funzione di servizio

Viene creato automaticamente un servizio ClusterIP per ogni funzione di servizio. 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 di mappa bpf su ciascun nodo per archiviare l'indirizzo IP del servizio

Per ogni funzione di servizio, su ciascun nodo viene creata una voce di mappa bpf per 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 è deviato 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 tuo 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 Geneve incapsulamento 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

• Leggi l'articolo Informazioni sul supporto di più reti per i pod
• Leggi l'articolo Informazioni sull'indirizzamento del servizio
• Leggi l'articolo Configurare il supporto di più reti per i pod.