Configurazione di un criterio di rete

Questa pagina mostra come utilizzare i criteri di rete del cluster per controllare se un pod può ricevere traffico di rete in entrata (o Ingress) e se può inviare traffico in uscita (o Egress).

I criteri di rete ti consentono di limitare le connessioni tra oggetti Pod, in modo da ridurre l'esposizione agli attacchi.

I criteri di rete agiscono come firewall al livello 3 o 4 del modello OSI. Non offrono funzionalità aggiuntive come autorizzazione o crittografia.

Limitazione del traffico in entrata agli oggetti Pod

Un oggetto NetworkPolicy ti consente di configurare i criteri di accesso alla rete per un pod. Gli oggetti NetworkPolicy contengono le seguenti informazioni:

  • Oggetti pod a cui si applica il criterio. Definisci gli oggetti Pod e i workload con etichette e selettori.

  • Tipo di traffico interessato dal criterio di rete: Ingress per il traffico in entrata, Egress per il traffico in uscita o entrambi.

  • Per i criteri in entrata, gli oggetti Pod che possono connettersi agli oggetti Pod specificati.

  • Per i criteri in uscita, gli oggetti Pod a cui possono collegarsi gli oggetti Pod specificati.

Esempio di limitazione del traffico in entrata

Questa sezione mostra la creazione di una limitazione del traffico in entrata su un'applicazione di esempio. Modifica questo esempio in base al tuo ambiente di applicazione.

  1. Esegui un'applicazione server web con l'etichetta app=hello ed esponila internamente nel cluster:

    kubectl run hello-web --labels app=hello \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 \
    --port 8080 --expose

  2. Configura un NetworkPolicy per consentire il traffico al pod hello-web solo dagli oggetti pod app=foo. GKE su AWS blocca il traffico in entrata proveniente da oggetti Pod che non hanno questa etichetta, nonché il traffico esterno e il traffico proveniente da oggetti Pod in uno spazio dei nomi diverso.

    Il seguente manifest seleziona gli oggetti Pod con l'etichetta app=hello e specifica un criterio di ingresso per consentire il traffico solo dagli oggetti Pod con l'etichetta app=foo:

    kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: hello-allow-from-foo
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: hello
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: foo

  3. Applica questo criterio al cluster:

    kubectl apply -f hello-allow-from-foo.yaml

Verifica il criterio in entrata

  1. Esegui un pod temporaneo con l'etichetta app=foo. Per verificare che il traffico in entrata sia consentito, invia una richiesta all'endpoint hello-web:8080:

    kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t foo-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    Se il traffico dal pod app=foo agli oggetti pod app=hello è abilitato, il risultato sarà simile al seguente:

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  2. Esegui un pod temporaneo con un'etichetta diversa (app=other) ed effettua la stessa richiesta per osservare che il traffico non è consentito:

    kubectl run -l app=other --image=alpine --restart=Never --rm -i -t other-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    L'output conferma che la connessione non riceve una risposta:

    wget: download timed out

Limita il traffico in uscita dagli oggetti pod

Puoi limitare il traffico in uscita come faresti con quello in entrata.

Tuttavia, per eseguire query sui nomi host interni come hello-web o esterni come www.example.com, devi creare un criterio di uscita che consenta il traffico DNS sulla porta 53 utilizzando i protocolli TCP e UDP.

Per attivare i criteri di rete in uscita, esegui il deployment di un NetworkPolicy che controlli il traffico in uscita dagli oggetti pod con l'etichetta app=foo, consentendo al contempo il traffico solo per gli oggetti pod con l'etichetta app=hello, nonché il traffico DNS.

Il seguente manifest specifica un NetworkPolicy che controlla il traffico in uscita da oggetti pod con etichetta app=foo con due destinazioni consentite:

  1. Oggetti pod nello stesso spazio dei nomi con l'etichetta app=hello
  2. Endpoint interni o esterni sulla porta 53 (UDP e TCP)
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: foo-allow-to-hello
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: foo
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: hello
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP

Applica questo criterio al cluster:

kubectl apply -f foo-allow-to-hello.yaml

Convalida il criterio in uscita

  1. Esegui il deployment di una nuova applicazione web chiamata hello-web-2 ed esponila internamente nel cluster:

    kubectl run hello-web-2 --labels app=hello-2 \
  --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080 --expose

  2. Esegui un pod temporaneo con l'etichetta app=foo e verifica che il pod possa stabilire connessioni con hello-web:8080:

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
  -- wget -qO- --timeout=2 http://hello-web:8080

    Il pod risponde alla richiesta:

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  3. Verifica che il pod non sia in grado di stabilire connessioni a hello-web-2:8080:

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://hello-web-2:8080

    L'output conferma che la connessione non riceve una risposta:

    wget: download timed out

  4. Verifica che il pod non sia in grado di stabilire connessioni a siti web esterni come www.example.com.

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://www.example.com

    L'output conferma che la connessione non riceve una risposta:

    wget: download timed out

Esegui la pulizia

Per rimuovere le risorse create in questo tutorial, esegui questi comandi:

kubectl delete pods --labels app=hello-2
kubectl delete pods --labels app=hello
kubectl delete -f foo-allow-to-hello.yaml
kubectl delete -f hello-allow-from-foo.yaml

Passaggi successivi