Netwerkbeleid in Kubernetes

Standaard accepteren pods verkeer van elke bron. Een netwerkbeleid helpt om te specificeren hoe een groep pods met elkaar en met andere netwerk eindpunten kan communiceren. NetworkPolicy gebruikt labels om pods te selecteren en definieert regels om te bepalen welk verkeer naar de geselecteerde pods wordt toegestaan Zodra er een NetworkPolicy op een bepaalde pod is toegepast, zal die pod verbindingen weigeren die de NetworkPolicy niet toestaat. De pods die niet door een NetworkPolicy zijn geselecteerd, zullen alle verkeer blijven accepteren.

Om meer in detail over NetworkPolicy te weten te komen, bezoek je de officiële pagina van Kubernetes hier.

In dit artikel zullen we het gebruik van Ingress en Egress NetworkPolicy zien, waarbij ingress inkomend verkeer naar de pod is, en egress uitgaand verkeer uit de pod.

Vereisten

  1. Kubernetes Cluster met minstens 1 worker node.
    Als je wilt leren hoe je een Kubernetes Cluster maakt, klik dan hier. Deze gids helpt je een Kubernetes cluster te maken met 1 Master en 2 Nodes op AWS Ubuntu 18.04 EC2 Instances.

Wat zullen we doen?

  1. Maak Netwerk Beleid

Maak Netwerk Beleid

Inkomend netwerk beleid

Maak een hello-web pod met een label “app-destination-pod” en service waarop we inkomend verkeer op poort 8080 zullen toestaan.

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

creat-a-pod-and-a-service

Maak een ingress definitiebestand met de volgende inhoud die verkeer op de “hello-web” pod met label “app=destination-pod” op poort 8080 toestaat vanaf de pod die overeenkomt met het label “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

ingress-network-policy-defination

Voordat we een ingress policy maken, maken we een pod met label “app=onbekend” die niet overeenkomt met de regel van het beleid.

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

Als we nu vanuit deze pod onze “hello-web” pod op poort 8080 proberen te benaderen, zal de pod bereikbaar zijn.

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

create-an-unknown-pod

Maak nu een beleid dat verbinding toelaat op de pod met label “app=destination-pod” vanuit de pod met label “app=source-pod” en haal er details van op.

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

creëer-ingress-netwerk-policy

Maak nu opnieuw een pod aan met een label dat niet overeenkomt met de in het beleid vastgelegde regel.

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

Als we opnieuw proberen de “hello-web” pod vanuit deze pod te benaderen, zal de “hello-web” pod niet bereikbaar zijn.

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

try-to-access-from-unknown-pod

Laten we deze keer een pod maken die overeenkomt met de regel van het netwerkbeleid, nl. pod met label “app=source-app”.

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

Als we nu proberen de “hello-web” pod te benaderen vanuit de pod met label “app=source-pod”, kan de “hello-web” wel bereikt worden.

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

probeer-toegang-van-bekende-pod

In de bovenstaande schermafbeelding zie je dat de “hello-web” pod toegankelijk was vanuit de pod met label “app=source-pod”. Dit betekent dat we verbindingen op ons “hello-web” beperkt hebben en dat alleen pods met het label “app=source-pod” er verbinding mee kunnen maken.

Egress Netwerk Beleid

Maak een nieuw bestand voor Egress Network Policy met de volgende inhoud.

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

egress-network-policy-defination

Het bovenstaande beleid zal uitgaande verbindingen toestaan van de pod met label “app=source-pod” naar de pod met label “app=destination-pod” en ook op poort 53 voor DNS resolutie.

Voordat we Egress Policy in het cluster toepassen, maak je een pod “hello-web-2” en dienst die niet met ons beleid overeenkomt.

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

create-unknown-application

Maak nu een pod met label “app=source-pod”.

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

Voordat we het Egress beleid toepassen, zijn zowel de apps “hello-web” als “hello-web-2” toegankelijk vanuit de pod met label “app=source-pod”.

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

toegang-tot-onbekende-toepassing-beschikbaar

Maak nu een Netwerkbeleid met egress regel.

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

creëer-egress-netwerk-policy

Laten we een pod maken met label “app=source-pod” en proberen de beide pods “app=source-pod” te benaderen

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

access-to-unknown-application-not-available

In de bovenstaande schermafbeelding zie je dat de pod “hello-web-2” deze keer niet bereikbaar was omdat hij niet overeenkomt met het egress beleid dat verbinding toestaat van een pod met label “app=source-pod” naar de pod met label “app=destination-pod”.

Conclusie

In dit artikel zagen we de stappen om een ingaand en uitgaand netwerkbeleid te maken. We zagen ook hoe de inkomende en uitgaande verbinding beperkt kunnen worden met respectievelijk ingress en egress en om dit beter te begrijpen zagen we de implementatie ervan met behulp van een eenvoudige web-app.