Configurar políticas de red para aplicaciones

En este tutorial se explica cómo usar las políticas de red de clúster para controlar qué pods reciben tráfico de red entrante y qué pods pueden enviar tráfico saliente. Para obtener más información, consulta el artículo Crear una política de red de clúster.

Las políticas de red te permiten limitar las conexiones entre pods. Por lo tanto, el uso de políticas de red proporciona una mayor seguridad al reducir el radio de vulneración.

Ten en cuenta que las políticas de red determinan si se permite una conexión y no ofrecen funciones de nivel superior, como la autorización o el transporte seguro (como SSL/TLS).

Crear un clúster de GKE con la implementación obligatoria de la política de red

Para crear un clúster de contenedores con la aplicación de la política de red, ejecuta el siguiente comando:

gcloud container clusters create test --enable-network-policy

Restringir el tráfico entrante a los pods

Los recursos de Kubernetes NetworkPolicy te permiten configurar políticas de acceso a la red para los pods. Los objetos NetworkPolicy contienen la siguiente información:

  • Pods a los que se aplican las políticas de red, normalmente designados por un selector de etiquetas

  • Tipo de tráfico al que afecta la política de red: entrada para el tráfico entrante, salida para el tráfico saliente o ambos

  • Para las políticas de entrada, los pods que pueden conectarse a los pods especificados

  • En el caso de las políticas de salida, los pods a los que pueden conectarse los pods especificados

Primero, ejecuta una aplicación de servidor web con la etiqueta app=hello y exponla internamente en el clúster:

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

A continuación, configura un NetworkPolicy para permitir el tráfico a los pods hello-web solo desde los pods app=foo. El resto del tráfico entrante de los pods que no tienen esta etiqueta, el tráfico externo y el tráfico de los pods en otros espacios de nombres están bloqueados.

El siguiente manifiesto selecciona los pods con la etiqueta app=hello y especifica una política de entrada para permitir el tráfico solo de los pods con la etiqueta 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

Para aplicar esta política en el clúster, ejecuta el siguiente comando:

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

Validar la política de entrada

Primero, ejecuta un pod temporal con la etiqueta app=foo y obtén un shell en el pod:

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

Envía una solicitud al endpoint hello-web:8080 para verificar que se permite el tráfico entrante:

/ # wget -qO- --timeout=2 http://hello-web:8080
 
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z
/ # exit

El tráfico del pod app=foo a los pods app=hello está habilitado.

A continuación, ejecuta un pod temporal con otra etiqueta (app=other) y obtén un shell dentro del pod:

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

Realiza la misma petición para observar que el tráfico no está permitido y, por lo tanto, la petición expira y sale del shell del pod:

/ # wget -qO- --timeout=2 http://hello-web:8080
 
wget: download timed out
/ # exit

Restringir el tráfico saliente de los pods

Puedes restringir el tráfico saliente de la misma forma que el tráfico entrante.

Sin embargo, para poder consultar nombres de host internos, como hello-web, o nombres de host externos, como www.example.com, debes permitir la resolución de DNS (sistema de nombres de dominio) en tus políticas de red de salida. El tráfico DNS se produce en el puerto 53 con protocolos TCP y UDP.

Para habilitar las políticas de red de salida, implementa una NetworkPolicy que controle el tráfico de salida de los pods con la etiqueta app=foo y que solo permita el tráfico a los pods con la etiqueta app=hello, así como el tráfico DNS.

El siguiente manifiesto especifica una política de red que controla el tráfico de salida de los pods con la etiqueta app=foo con dos destinos permitidos:

  1. Pods en el mismo espacio de nombres con la etiqueta app=hello.
  2. Pods de clúster o endpoints externos en el puerto 53 (UDP y 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

Para aplicar esta política en el clúster, ejecuta el siguiente comando:

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

Validar la política de salida

Primero, despliega una nueva aplicación web llamada hello-web-2 y exponla internamente en el clúster:

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

A continuación, ejecuta un pod temporal con la etiqueta app=foo y abre un shell dentro del contenedor:

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

Valida que el pod puede establecer conexiones con hello-web:8080:

/ # wget -qO- --timeout=2 http://hello-web:8080
 
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

Valida que el pod no puede establecer conexiones con hello-web-2:8080:

/ # wget -qO- --timeout=2 http://hello-web-2:8080
 
wget: download timed out

Valida que el pod no puede establecer conexiones con sitios web externos, como www.example.com, y sal de la shell del pod.

/ # wget -qO- --timeout=2 http://www.example.com
 
wget: download timed out
/ # exit