Configura políticas de red para aplicaciones

En este instructivo, se muestra cómo usar las políticas de red del clúster para controlar qué Pods reciben tráfico de red entrante y cuáles pueden enviar tráfico saliente. Para obtener más información, consulta Crea una política de red del clúster.

Las políticas de red te permiten limitar las conexiones entre pods. Por lo tanto, usar las Políticas de red proporciona una mejor seguridad mediante la reducción del radio de compromiso.

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

Objetivos

En este instructivo, aprenderás lo siguiente:

  • Cómo crear clústeres con la aplicación de políticas de red
  • Cómo restringir el tráfico entrante a pods usando etiquetas
  • Cómo restringir el tráfico saliente de pods usando etiquetas

Antes de comenzar

Sigue los pasos que se indican a continuación para habilitar la API de Kubernetes Engine:
  1. Consulta la página de Kubernetes Engine en Google Cloud Console.
  2. Crea o selecciona un proyecto.
  3. Espera a que la API y los servicios relacionados se habiliten. Esto puede tardar varios minutos.
  4. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

Instala las siguientes herramientas de línea de comandos de este instructivo:

  • gcloud se usa para crear y borrar clústeres de Kubernetes Engine. gcloud se incluye en el SDK de Google Cloud.
  • kubectl se usa para administrar Kubernetes, el sistema de organización de clústeres que emplea Kubernetes Engine. Puedes instalar kubectl con gcloud:
    gcloud components install kubectl

Clona el código de ejemplo desde GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/network-policies

Establece valores predeterminados para la herramienta de línea de comandos de gcloud

Para ahorrar tiempo cuando escribes las opciones del ID del proyecto y la zona de Compute Engine en la herramienta de línea de comandos de gcloud, puedes establecer valores predeterminados:
gcloud config set project project-id
gcloud config set compute/zone compute-zone

Crea un clúster de GKE

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

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

Restringe el tráfico que entra a los pods

Los recursos NetworkPolicy de Kubernetes 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; por lo general, se designan a través de un selector de etiquetas.

  • Tipo de tráfico que afecta a la política de red: Ingress para tráfico entrante, Egress para tráfico saliente o ambos.

  • Para las políticas de entrada, qué pods pueden conectarse a los pods especificados.

  • Para las políticas de salida, los pods a los que se pueden conectar los pods especificados.

Primero, ejecuta una aplicación de servidor web simple con la etiqueta app=hello y exponla de manera interna 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 una NetworkPolicy para permitir el tráfico a los Pods hello-web solo desde los Pods app=foo. El tráfico entrante de pods que no tiene esta etiqueta, el tráfico externo y el tráfico de pods en otros espacios de nombres se bloquean.

El siguiente manifiesto selecciona pods con la etiqueta app=hello y especifica una política de entrada para permitir el tráfico solo desde 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 al clúster, ejecuta el siguiente comando:

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

Valida la política de entrada

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

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

Realiza una solicitud al extremo hello-web:8080 para verificar que se permita 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 una etiqueta diferente (app=other) y obtén una shell dentro del pod:

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

Realiza la misma solicitud para observar que el tráfico no esté permitido y, por lo tanto, se agote el tiempo de espera de la solicitud y sal del pod de shell:

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

Restringe el tráfico que sale de los pods

Puedes restringir el tráfico saliente como lo harías con el tráfico entrante.

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

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

En el siguiente manifiesto, se 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 del clúster o extremos 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 al clúster, ejecuta el siguiente comando:

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

Valide la política de salida

Primero, implementa una aplicación web nueva llamada hello-web-2 y exhíbela de manera interna 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 una shell dentro del contenedor:

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

Verifica que el pod pueda 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

Verifica que el pod no pueda establecer conexiones con hello-web-2:8080:

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

Verifica que el pod no pueda establecer conexiones con sitios web externos como www.example.com y sal del shell del pod.

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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  1. Borra el clúster del contenedor: este paso borrará los recursos que conforman clústeres del contenedor, como las instancias de procesamiento, los discos y los recursos de red.

    gcloud container clusters delete test

¿Qué sigue?