**Ayude a mejorar esta página**
Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.
# Configuración de políticas de red de Kubernetes para nodos híbridos
AWS admite las políticas de red de Kubernetes (capa 3 o 4) para el tráfico de entrada y salida de los pods cuando se utiliza Cilium como CNI con Nodos híbridos EKS. Si ejecuta clústeres de EKS con nodos en la nube de AWS, AWS es compatible con las [políticas de red de la CNI de Amazon VPC para Kubernetes](cni-network-policy.md).
En este tema se explica cómo configurar las políticas de red de Cilium y Kubernetes con Nodos híbridos de EKS. Para obtener información detallada sobre las políticas de red de Kubernetes, consulte [Kubernetes Network Policies](https://kubernetes.io/docs/concepts/services-networking/network-policies/) en la documentación de Kubernetes.
## Configurar políticas de red
### Consideraciones
+ AWS es compatible con las políticas de red ascendentes de Kubernetes y la especificación para la entrada y salida de pods. AWS actualmente no es compatible con `CiliumNetworkPolicy` ni `CiliumClusterwideNetworkPolicy`.
+ El valor de Helm `policyEnforcementMode` se puede utilizar para controlar el comportamiento de aplicación predeterminado de las políticas de Cilium. El comportamiento predeterminado permite todo el tráfico de entrada y salida. Cuando una política de red selecciona un punto de conexión, pasa a un estado de denegación predeterminado, en el que solo se permite el tráfico explícitamente permitido. Consulte la documentación de Cilium para obtener más información sobre el [modo de políticas predeterminados](https://docs.cilium.io/en/stable/security/policy/intro/#policy-mode-default) y los [modos de aplicación de políticas](https://docs.cilium.io/en/stable/security/policy/intro/#policy-enforcement-modes).
+ Si cambia `policyEnforcementMode` para una instalación de Cilium existente, debe reiniciar el DaemonSet del agente de Cilium para aplicar el nuevo modo de aplicación de políticas.
+ Utilice `namespaceSelector` y `podSelector` para permitir o denegar el tráfico hacia o desde los espacios de nombres y los pods con etiquetas coincidentes. `namespaceSelector` y `podSelector` se pueden usar con `matchLabels` o `matchExpressions` para seleccionar espacios de nombres y pods en función de sus etiquetas.
+ Utilice `ingress.ports` y `egress.ports` para permitir o denegar el tráfico hacia o desde puertos y protocolos.
+ El campo `ipBlock` no se puede utilizar para permitir o denegar de forma selectiva el tráfico hacia o desde las direcciones IP de los pods ([\$19209](https://github.com/cilium/cilium/issues/9209)). El uso de selectores `ipBlock` para las IP de los nodos es una característica en versión beta de Cilium y no es compatible con AWS.
+ Consulte [NetworkPolicy resource](https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource) en la documentación de Kubernetes para obtener información sobre los campos disponibles para las políticas de red de Kubernetes.
### Requisitos previos
+ Se instaló Cilium según las instrucciones de [Configuración de una CNI para nodos híbridos](hybrid-nodes-cni.md).
+ Si tiene Helm instalado en su entorno de línea de comandos, consulte las [instrucciones de configuración de Helm](helm.md).
### Procedimiento
El siguiente procedimiento configura las políticas de red para una aplicación de microservicios de ejemplo, de modo que los componentes solo pueden comunicarse con otros componentes necesarios para que la aplicación funcione. El procedimiento utiliza la aplicación de microservicios de ejemplo [Istio BookInfo](https://istio.io/latest/docs/examples/bookinfo/).
La aplicación BookInfo consta de cuatro microservicios independientes con las siguientes relaciones:
+ **productpage**. El microservicio productpage llama a los microservicios details y reviews para rellenar la página.
+ **details**. El microservicio details contiene información sobre libros.
+ **reviews**. El microservicio reviews contiene reseñas de libros. También llama al microservicio ratings.
+ **ratings**. El microservicio ratings contiene información de clasificación de libros que acompaña a la reseña de un libro.
1. Cree la aplicación de ejemplo.
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. Confirme que la aplicación se esté ejecutando correctamente y anote la dirección IP del pod del microservicio productpage. Utilizará la dirección IP de este pod para consultar cada microservicio en los pasos siguientes.
```
kubectl get pods -o wide
```
```
NAME READY STATUS RESTARTS AGE IP NODE
details-v1-766844796b-9wff2 1/1 Running 0 7s 10.86.3.7 mi-0daa253999fe92daa
productpage-v1-54bb874995-lwfgg 1/1 Running 0 7s 10.86.2.193 mi-082f73826a163626e
ratings-v1-5dc79b6bcd-59njm 1/1 Running 0 7s 10.86.2.232 mi-082f73826a163626e
reviews-v1-598b896c9d-p2289 1/1 Running 0 7s 10.86.2.47 mi-026d6a261e355fba7
reviews-v2-556d6457d-djktc 1/1 Running 0 7s 10.86.3.58 mi-0daa253999fe92daa
reviews-v3-564544b4d6-g8hh4 1/1 Running 0 7s 10.86.2.69 mi-09183e8a3d755abf6
```
1. Cree un pod que se utilizará en todo momento para probar las políticas de red. Tenga en cuenta que el pod se crea en el espacio de nombres `default` con la etiqueta `access: true`.
```
kubectl run curl-pod --image=curlimages/curl -i --tty --labels=access=true --namespace=default --overrides='{"spec": { "nodeSelector": {"eks.amazonaws.com/compute-type": "hybrid"}}}' -- /bin/sh
```
1. Pruebe el acceso al microservicio productpage. En el siguiente ejemplo, utilizamos la dirección IP del pod productpage (`10.86.2.193`) para consultar el microservicio. Sustitúyala por la dirección IP del pod productpage de su entorno.
```
curl -s http://10.86.2.193:9080/productpage | grep -o ".*"
```
```
Simple Bookstore App
```
1. Para salir del pod curl de prueba, puede escribir `exit`. Para volver a conectarse al pod, ejecute el siguiente comando.
```
kubectl attach curl-pod -c curl-pod -i -t
```
1. Para demostrar los efectos de las políticas de red en los siguientes pasos, primero creamos una política de red que deniegue todo el tráfico de los microservicios de BookInfo. Cree un archivo llamado `network-policy-deny-bookinfo.yaml` que defina la política de red de denegación.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-bookinfo
namespace: default
spec:
podSelector:
matchExpressions:
- key: app
operator: In
values: ["productpage", "details", "reviews", "ratings"]
policyTypes:
- Ingress
- Egress
```
1. Aplique la política de red de denegación al clúster.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
1. Pruebe el acceso a la aplicación BookInfo. En el siguiente ejemplo, utilizamos la dirección IP del pod productpage (`10.86.2.193`) para consultar el microservicio. Sustitúyala por la dirección IP del pod productpage de su entorno.
```
curl http://10.86.2.193:9080/productpage --max-time 10
```
```
curl: (28) Connection timed out after 10001 milliseconds
```
1. Cree un archivo llamado `network-policy-productpage.yaml` que defina la política de red de productpage. La política tiene las siguientes reglas:
+ Permite la entrada de tráfico desde los pods con la etiqueta `access: true` (el pod curl creado en el paso anterior).
+ Permite el tráfico TCP de salida en el puerto `9080` para los microservicios details, reviews y ratings.
+ Permite el tráfico TCP/UDP de salida en el puerto `53` para CoreDNS que se ejecuta en el espacio de nombres `kube-system`.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: productpage-policy
namespace: default
spec:
podSelector:
matchLabels:
app: productpage
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
access: "true"
egress:
- to:
- podSelector:
matchExpressions:
- key: app
operator: In
values: ["details", "reviews", "ratings"]
ports:
- port: 9080
protocol: TCP
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- port: 53
protocol: UDP
- port: 53
protocol: TCP
```
1. Aplique la política de red de productpage a su clúster.
```
kubectl apply -f network-policy-productpage.yaml
```
1. Conéctese al pod curl y pruebe el acceso a la aplicación BookInfo. Ahora se permite el acceso al microservicio productpage, pero se sigue denegando el acceso a los demás microservicios porque siguen sujetos a la política de red de denegación. En los siguientes ejemplos, utilizamos la dirección IP del pod productpage (`10.86.2.193`) para consultar el microservicio. Sustitúyala por la dirección IP del pod productpage de su entorno.
```
kubectl attach curl-pod -c curl-pod -i -t
```
```
curl -s http://10.86.2.193:9080/productpage | grep -o ".*"
Simple Bookstore App
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1
{"error": "Sorry, product details are currently unavailable for this book."}
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
{"error": "Sorry, product reviews are currently unavailable for this book."}
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
{"error": "Sorry, product ratings are currently unavailable for this book."}
```
1. Cree un archivo llamado `network-policy-details.yaml` que defina la política de red de details. La política solo permite la entrada de tráfico desde el microservicio productpage.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: details-policy
namespace: default
spec:
podSelector:
matchLabels:
app: details
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: productpage
```
1. Cree un archivo llamado `network-policy-reviews.yaml` que defina la política de red de reviews. La política solo permite el tráfico de entrada desde el microservicio productpage y solo el tráfico de salida hacia el microservicio ratings y CoreDNS.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: reviews-policy
namespace: default
spec:
podSelector:
matchLabels:
app: reviews
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
app: productpage
egress:
- to:
- podSelector:
matchLabels:
app: ratings
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- port: 53
protocol: UDP
- port: 53
protocol: TCP
```
1. Cree un archivo llamado `network-policy-ratings.yaml` que defina la política de red de ratings. La política solo permite la entrada de tráfico desde los microservicios productpage y reviews.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: ratings-policy
namespace: default
spec:
podSelector:
matchLabels:
app: ratings
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchExpressions:
- key: app
operator: In
values: ["productpage", "reviews"]
```
1. Aplique al clúster las políticas de red de details, reviews y ratings.
```
kubectl apply -f network-policy-details.yaml
kubectl apply -f network-policy-reviews.yaml
kubectl apply -f network-policy-ratings.yaml
```
1. Conéctese al pod curl y pruebe el acceso a la aplicación BookInfo. En los siguientes ejemplos, utilizamos la dirección IP del pod productpage (`10.86.2.193`) para consultar el microservicio. Sustitúyala por la dirección IP del pod productpage de su entorno.
```
kubectl attach curl-pod -c curl-pod -i -t
```
Pruebe el microservicio details.
```
curl -s http://10.86.2.193:9080/api/v1/products/1
```
```
{"id": 1, "author": "William Shakespeare", "year": 1595, "type": "paperback", "pages": 200, "publisher": "PublisherA", "language": "English", "ISBN-10": "1234567890", "ISBN-13": "123-1234567890"}
```
Pruebe el microservicio reviews.
```
curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
```
```
{"id": "1", "podname": "reviews-v1-598b896c9d-p2289", "clustername": "null", "reviews": [{"reviewer": "Reviewer1", "text": "An extremely entertaining play by Shakespeare. The slapstick humour is refreshing!"}, {"reviewer": "Reviewer2", "text": "Absolutely fun and entertaining. The play lacks thematic depth when compared to other plays by Shakespeare."}]}
```
Pruebe el microservicio ratings.
```
curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
```
```
{"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}
```
1. Limpie los recursos que ha creado en este procedimiento.
```
kubectl delete -f network-policy-deny-bookinfo.yaml
kubectl delete -f network-policy-productpage.yaml
kubectl delete -f network-policy-details.yaml
kubectl delete -f network-policy-reviews.yaml
kubectl delete -f network-policy-ratings.yaml
kubectl delete -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
kubectl delete pod curl-pod
```