Política de red en Kubernetes

Por defecto, los pods aceptan tráfico de cualquier origen. Una política de red ayuda a especificar cómo un grupo de pods puede comunicarse entre sí y con otros puntos finales de la red. NetworkPolicy utiliza etiquetas para seleccionar los pods y definir reglas para especificar qué tráfico se permite a los pods seleccionados Una vez que haya una NetworkPolicy aplicada en un pod concreto, ese pod rechazará las conexiones que no permita la NetworkPolicy. Los pods que no estén seleccionados por ninguna NetworkPolicy seguirán aceptando todo el tráfico.

Para saber más sobre NetworkPolicy en detalle, visita la página oficial de Kubernetes aquí.

En este artículo, veremos el uso de Ingress y Egress NetworkPolicy donde ingress es el tráfico entrante al pod, y egress es el tráfico saliente del pod.

Requisitos previos

1. Clúster Kubernetes con al menos 1 nodo trabajador.
   Si quieres aprender a crear un Clúster Kubernetes, haz clic aquí. Esta guía te ayudará a crear un clúster Kubernetes con 1 Maestro y 2 Nodos en Instancias EC2 de AWS Ubuntu 18.04.

¿Qué haremos?

1. Crear políticas de red

Crear políticas de red

Política de red de entrada

Crea un pod hello-web con la etiqueta «app-destination-pod» y un servicio en el que permitiremos el tráfico de entrada en el puerto 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 archivo de definición de entrada con el siguiente contenido que permita el tráfico en el pod «hello-web» con etiqueta «app=destination-pod» en el puerto 8080 desde el pod que coincida con la etiqueta «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

Antes de crear una política de entrada, creamos un pod con la etiqueta «app=unknown» que no coincide con la regla de la política.

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

Ahora cuando intentemos acceder a nuestro pod «hello-web» en el puerto 8080 desde este pod, el pod será accesible.

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

Ahora crea una política que permita la conexión en el pod con etiqueta «app=destination-pod» desde el pod con etiqueta «app=source-pod» y obtén los detalles de la misma.

kubectl apply -f ingress.yml

kubectl get networkpolicy destination-pod-allow-from-source-pod

Ahora, crea de nuevo un pod con una etiqueta que no coincida con la regla definida en la política.

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

Si volvemos a intentar acceder al pod «hola-web» desde este pod, el pod «hola-web» no será accesible.

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

Esta vez, vamos a crear un pod que coincida con la regla de la política de red, es decir, un pod con la etiqueta «app=source-app»

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

Ahora, si intentamos acceder al pod «hello-web» desde el pod con etiqueta «app=source-pod», se podrá acceder a «hello-web».

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

En la captura de pantalla anterior, puedes ver que el pod «hello-web» era accesible desde el pod con etiqueta «app=source-pod». Esto significa que hemos restringido las conexiones en nuestro «hello-web» y sólo los pods con etiqueta «app=pod-fuente» pueden conectarse a él.

Política de red de salida

Crea un nuevo archivo para la Política de Red de Salida con el siguiente contenido.

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

La política anterior permitirá las conexiones salientes del pod con etiqueta «app=pod-fuente» al pod con etiqueta «app=pod-destino» y también en el puerto 53 para la resolución DNS.

Antes de aplicar la política de salida en el clúster, crea un pod «hello-web-2» y un servicio que no coincida con nuestra política.

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

Ahora crea un pod con la etiqueta «app=source-pod».

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

Antes de aplicar la política de salida, se puede acceder a las aplicaciones «hello-web» y «hello-web-2» desde el pod con la etiqueta «app=source-pod»

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

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

Ahora, crea una política de Red con regla de salida.

kubectl create -f egress.yml

kubectl get networkpolicy | grep source-pod-allow-to-destination-pod

Creemos un pod con la etiqueta «app=pod-fuente» e intentemos acceder a ambos pods «app=pod-fuente»

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

En la captura de pantalla anterior, puedes observar que esta vez no se ha podido acceder al pod «hello-web-2» porque no coincide con la política de salida que permite la conexión desde un pod con etiqueta «app=pod-fuente» al pod con etiqueta «app=pod-destino».

Conclusión

En este artículo hemos visto los pasos para crear una política de red de entrada y salida. También hemos visto cómo se puede restringir la conexión entrante y saliente mediante la entrada y la salida, respectivamente, y para entenderlo mejor hemos visto su implementación mediante una sencilla aplicación web.