Ricerca nel sito web

Politica di rete in Kubernetes

Per impostazione predefinita, i pod accettano il traffico da qualsiasi origine. Un criterio di rete consente di specificare come un gruppo di pod può comunicare tra loro e con altri endpoint di rete. NetworkPolicy utilizza etichette per selezionare i pod e definire regole per specificare quale traffico è consentito ai pod selezionati Una volta applicato un NetworkPolicy su un particolare pod, quel pod rifiuterà le connessioni a cui non è consentito NetworkPolicy. I pod che non sono selezionati da alcun NetworkPolicy continueranno ad accettare tutto il traffico.

Per saperne di più su NetworkPolicy in dettaglio, visita la pagina ufficiale di Kubernetes qui.

In questo articolo vedremo l'utilizzo di Ingress e Egress NetworkPolicy in cui l'ingresso è il traffico in entrata al pod e l'uscita è il traffico in uscita dal pod.

Prerequisiti

  1. Cluster Kubernetes con almeno 1 nodo di lavoro.
    Se vuoi imparare a creare un cluster Kubernetes, fai clic qui. Questa guida ti aiuterà a creare un cluster Kubernetes con 1 master e 2 nodi su istanze AWS Ubuntu 18.04 EC2.

Che cosa faremo?

  1. Crea criteri di rete

Crea criteri di rete

Criterio di rete in ingresso

Crea un pod hello-web con un'etichetta \app-destination-pod\ e un servizio su cui consentiremo il traffico in entrata sulla porta 8080.

kubectl run hello-web --labels app=destination-pod --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --
kubectl get pod | grep hello-web

kubectl get service | grep hello-web

Crea un file di definizione in entrata utilizzando i seguenti contenuti che consentano il traffico sul pod \hello-web\ con l'etichetta \app=destination-pod\ sulla porta 8080 dal pod che corrisponde all'etichetta \app=source-pod\ .

vim ingress.yml
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: destination-pod-allow-from-source-pod
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: destination-pod
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: source-pod

Prima di creare un criterio in entrata, crea un pod con l'etichetta \app=unknown\ che non corrisponde alla regola del criterio.

kubectl run -l app=unknown --image=alpine --restart=Never --rm -i -t test-1

Ora, quando proviamo ad accedere al nostro pod \hello-web\ sulla porta 8080 da questo pod, il pod sarà accessibile.

wget -qO- --timeout=2 http://hello-web:8080

Ora crea una policy che consenta la connessione sul pod con l'etichetta \app=destination-pod\ dal pod con l'etichetta \app=source-pod\ e ottieni i relativi dettagli.

kubectl apply -f ingress.yml
kubectl get networkpolicy destination-pod-allow-from-source-pod

Ora, crea nuovamente un pod con un'etichetta che non corrisponde alla regola definita nel criterio.

kubectl run -l app=unknown --image=alpine --restart=Never --rm -i -t test-1

Se tentiamo nuovamente di accedere al pod \hello-web\ da questo pod, il pod \hello-web\ non sarà raggiungibile.

wget -qO- --timeout=2 http://hello-web:8080

Questa volta, creiamo un pod che corrisponda alla regola dei criteri di rete, ad esempio un pod con l'etichetta \app=source-app\

kubectl run -l app=source-pod --image=alpine --restart=Never --rm -i -t test-1

Ora, se proviamo ad accedere al pod \hello-web\ dal pod con l'etichetta \app=source-pod\, è possibile accedere a \hello-web\.

wget -qO- --timeout=2 http://hello-web:8080

Nello screenshot qui sopra, puoi vedere che il pod \hello-web\ era accessibile dal pod con l'etichetta \app=source-pod\. Ciò significa che abbiamo limitato le connessioni sul nostro \hello-web\ e solo i pod con l'etichetta \app=source-pod\ possono connettersi ad esso.

Criterio di rete in uscita

Crea un nuovo file per i criteri di rete in uscita con il seguente contenuto.

vim egress.yml
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: source-pod-allow-to-destination-pod
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: source-pod
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: destination-pod
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP

Il criterio precedente consentirà le connessioni in uscita dal pod con etichetta \app=source-pod\ al pod con etichetta \app=destination-pod\ e anche sulla porta 53 per la risoluzione DNS.

Prima di applicare la policy in uscita nel cluster, crea un pod \hello-web-2\ e un servizio che non corrisponde alla nostra policy.

kubectl run hello-web-2 --labels app=hello-2 --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose
kubectl get pod | grep hello-web-2
kubectl get service | grep hello-web-2

Ora crea un pod con l'etichetta \app=source-pod\.

kubectl run -l app=source-pod --image=alpine --restart=Never --rm -i -t test-2

Prima di applicare il criterio di uscita, è possibile accedere a entrambe le app \hello-web\ e \hello-web-2\ dal pod con l'etichetta \app=source-pod\

wget -qO- --timeout=2 http://hello-web:8080
wget -qO- --timeout=2 http://hello-web-2:8080

Ora crea un criterio di rete con la regola di uscita.

kubectl create -f egress.yml
kubectl get networkpolicy | grep source-pod-allow-to-destination-pod

Creiamo un pod con etichetta \app=source-pod\ e proviamo ad accedere ad entrambi i pod \app=source-pod\

kubectl run -l app=source-pod --image=alpine --restart=Never --rm -i -t test-3

wget -qO- --timeout=2 http://hello-web:8080 

wget -qO- --timeout=2 http://hello-web-2:8080

Nello screenshot sopra, puoi osservare che questa volta il pod \hello-web-2\ non era raggiungibile in quanto non corrisponde alla politica di uscita che consente la connessione da un pod con etichetta \app=source-pod\ al pod con etichetta \app=destination-pod\.

Conclusione

In questo articolo, abbiamo visto i passaggi per creare un criterio di rete in entrata e in uscita. Abbiamo anche visto come la connessione in entrata e in uscita può essere limitata utilizzando rispettivamente l'ingresso e l'uscita e per capirlo meglio abbiamo visto la sua implementazione utilizzando una semplice app web.