Esta documentación es para la versión más reciente de los clústeres de Anthos en AWS, que se lanzó el 3 de noviembre. Consulta las notas de la versión para obtener más información. Para obtener documentación sobre la generación anterior de clústeres de Anthos en AWS, consulta Generación anterior.

Configurar una política de red

En esta página, se muestra cómo usar las políticas de red del clúster para controlar si un Pod puede recibir tráfico de red entrante (o de entrada) y si puede enviar tráfico saliente (o de salida).

Las políticas de red te permiten limitar las conexiones entre objetos del Pod, por lo que puedes reducir la exposición a ataques.

Las políticas de red actúan como un firewall en la capa 3 o en la capa 4 del modelo OSI. No ofrecen funciones adicionales, como la autorización o la encriptación.

Restringe el tráfico entrante a objetos del Pod

Un objeto NetworkPolicy te permite configurar políticas de acceso a la red para un Pod. Los objetos NetworkPolicy contienen la siguiente información:

Objetos del Pod a los que se aplica la política. Define los objetos y las cargas de trabajo del Pod con etiquetas y selectores.
Tipo de tráfico de Internet que afecta a la política de red: Ingress Tráfico entrante, Egress tráfico saliente o ambos.
Para las políticas de entrada, qué objetos del Pod pueden conectarse a los objetos del Pod especificados.
Para las políticas de salida, los objetos del Pod a los que se pueden conectar los objetos especificados del Pod.

Restricción del tráfico entrante de ejemplo

En esta sección, se muestra cómo crear una restricción del tráfico entrante en una aplicación de muestra. Modifica este ejemplo para que se adapte a tu propio entorno de aplicaciones.

Ejecuta una aplicación de servidor web 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

Configura una NetworkPolicy para permitir el tráfico al Pod hello-web solo desde los objetos del Pod app=foo. GKE en AWS bloquea el tráfico entrante de los objetos de Pod que no tienen esta etiqueta, así como el tráfico externo y el tráfico de los objetos de Pod en un espacio de nombres diferente.

En el siguiente manifiesto, se seleccionan los objetos del Pod con la etiqueta app=hello y especifica una política de entrada para permitir solo el tráfico desde los objetos del Pod 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
```

Aplica esta política al clúster:

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

Verifica la política de entrada

Ejecuta un Pod temporal con la etiqueta app=foo. Para verificar que se permita el tráfico entrante, realiza una solicitud al extremo hello-web:8080:
```
kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t foo-app \
    -- wget -qO- --timeout=2 http://hello-web:8080
```
Si el tráfico del Pod app=foo a los objetos del Pod app=hello está habilitado, el resultado se verá de la siguiente manera:
```
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z
```
Ejecuta un pod temporal con una etiqueta diferente (app=other) y realiza la misma solicitud para observar que el tráfico no esté permitido:
```
kubectl run -l app=other --image=alpine --restart=Never --rm -i -t other-app \
    -- wget -qO- --timeout=2 http://hello-web:8080
```
El resultado confirma que la conexión no recibe una respuesta:
```
wget: download timed out
```

Restringe el tráfico saliente de los objetos del Pod

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

Sin embargo, para consultar nombres de host internos como hello-web o externos como www.example.com, debes crear una política de salida que permita el tráfico de DNS en el puerto 53 con los protocolos TCP y UDP.

Para habilitar políticas de red de salida, implementa un NetworkPolicy que controle el tráfico saliente desde los objetos del pod con la etiqueta app=foo y permita el tráfico solo a objetos del pod con la etiqueta app=hello y también Tráfico de DNS

En el siguiente manifiesto, se especifica un NetworkPolicy que controla el tráfico de salida de los objetos del Pod con la etiqueta app=foo y dos destinos permitidos:

Objetos del Pod en el mismo espacio de nombres con la etiqueta app=hello
Extremos internos o 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

Aplica esta política al clúster:

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 valida que el pod pueda establecer conexiones con hello-web:8080:

kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
  -- wget -qO- --timeout=2 http://hello-web:8080

El Pod responde a la solicitud:

Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

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

kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://hello-web-2:8080

El resultado confirma que la conexión no recibe una respuesta:

wget: download timed out

Verifica que el Pod no pueda establecer conexiones con sitios web externos, como www.example.com.
```
kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://www.example.com
```
El resultado confirma que la conexión no recibe una respuesta:
```
wget: download timed out
```

Limpia

Para quitar los recursos que creaste en este instructivo, ejecuta estos comandos:

kubectl delete pods --labels app=hello-2
kubectl delete pods --labels app=hello
kubectl delete -f foo-allow-to-hello.yaml
kubectl delete -f hello-allow-from-foo.yaml

¿Qué sigue?

Documentación de las políticas de red de Kubernetes
Usa el registro de políticas de red para registrar cuándo las políticas de red del clúster permiten o rechazan las conexiones a los Pods.