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.

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 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 y los modos de aplicación de políticas.
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 (#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 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.
Si tiene Helm instalado en su entorno de línea de comandos, consulte las instrucciones de configuración de Helm.

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.

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.

Cree la aplicación de ejemplo.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

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

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

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 "<title>.*</title>"
```
```
<title>Simple Bookstore App</title>
```
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
```

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

Aplique la política de red de denegación al clúster.


kubectl apply -f network-policy-default-deny-bookinfo.yaml

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
```

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

Aplique la política de red de productpage a su clúster.
```
kubectl apply -f network-policy-productpage.yaml
```

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 "<title>.*</title>"
<title>Simple Bookstore App</title>


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."}

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

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

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"]

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

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}}

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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Configuración de servicios de LoadBalancer

Funcionamiento