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.

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 reduciendo el radio de compromiso.

Esta página explica cómo configurar las políticas de red en GKE.

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 Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu 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

Cómo establecer 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 los valores predeterminados:
gcloud config set project project-id
gcloud config set compute/zone compute-zone

Paso 1: Crea un GKE

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

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

Paso 2: Restringe el tráfico entrante a los pods

Los recursos NetworkPolicy de Kubernetes te permiten configurar políticas de acceso a la red para los pods. NetworkPolicy contiene 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 de Internet al que afecta la política de red: Ingress para el tráfico entrante, Egress destinado al 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=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose

A continuación, debes configurar un 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 o el tráfico de pods en otros espacios de nombres se bloquean.

Guarda la configuración siguiente en hello-allow-from-foo.yaml:

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

Esta política selecciona los pods con la etiqueta app=hello y especifica una política de ingreso para permitir el tráfico solo desde los pods con la etiqueta app=foo.

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

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

Paso 3: Restringe el tráfico saliente de los pods

Puedes restringir el tráfico saliente (salida) 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 ejercer 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.

Guarda la configuración siguiente en foo-allow-to-hello.yaml y aplícala al clúster:

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
kubectl apply -f foo-allow-to-hello.yaml

En este 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)

Valida 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=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose

A continuación, ejecuta un pod temporal con la etiqueta app=foo y obtén un indicador de 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 puede 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

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

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

    gcloud container clusters delete test

Próximos pasos