Configurer les politiques réseau Kubernetes pour les nœuds hybrides

AWS prend en charge les politiques réseau Kubernetes (couche 3 / couche 4) pour le trafic entrant et sortant des pods lors de l’utilisation de Cilium comme CNI avec les nœuds hybrides EKS. Si vous exécutez des clusters EKS avec des nœuds dans le cloud AWS, AWS prend en charge Amazon VPC CNI pour les politiques réseau Kubernetes.

Cette rubrique explique comment configurer Cilium et les politiques réseau Kubernetes avec les nœuds hybrides EKS. Pour plus d’informations sur les politiques réseau Kubernetes, consultez la section Politiques réseau Kubernetes dans la documentation Kubernetes.

Configurer des stratégies réseau

Considérations

AWS prend en charge les politiques réseau Kubernetes en amont et les spécifications pour les pods ingress et egress. AWS ne prend actuellement pas en charge ni CiliumNetworkPolicy ni CiliumClusterwideNetworkPolicy.
La valeur Helm policyEnforcementMode peut être utilisée pour contrôler le comportement par défaut de l’application des politiques Cilium. Le comportement par défaut autorise tout le trafic sortant et entrant. Lorsqu’un point de terminaison est sélectionné par une stratégie réseau, il passe à un état de refus par défaut, dans lequel seul le trafic explicitement autorisé est autorisé. Consultez la documentation Cilium pour plus d’informations sur le mode de politique par défaut et les modes d’application des politiques.
Si vous modifiez policyEnforcementMode pour une installation Cilium existante, vous devez redémarrer le DaemonSet de l’agent Cilium pour appliquer le nouveau mode d’application des politiques.
Utilisez namespaceSelector et podSelector pour autoriser ou refuser le trafic vers/depuis les espaces de noms et les pods avec des étiquettes correspondantes. Le namespaceSelector et podSelector peut être utilisé avec matchLabels ou matchExpressions pour choisir des espaces de noms et des pods en fonction de leurs étiquettes.
Utilisez ingress.ports et egress.ports pour autoriser ou refuser le trafic vers/depuis les ports ainsi que les protocoles.
Le champ ipBlock ne peut pas être utilisé pour autoriser ou refuser de façon sélective le trafic vers/depuis les adresses IP des pods (#9209). Utiliser des sélecteurs ipBlock pour les adresses IP des nœuds est une fonctionnalité bêta de Cilium qui n’est pas prise en charge par AWS.
Consultez la ressource NetworkPolicy dans la documentation Kubernetes pour obtenir des informations sur les champs disponibles pour les politiques réseau Kubernetes.

Prérequis

Cilium installé en suivant les instructions dans Configurer CNI pour les nœuds hybrides.
Helm installé dans votre environnement de ligne de commande, consultez les Instructions de configuration de Helm.

Procédure

La procédure suivante configure les stratégies réseau pour un exemple d’application de microservices afin que les composants ne puissent communiquer qu’avec les autres composants nécessaires au fonctionnement de l’application. La procédure utilise l’application microservices Istio Bookinfo.

L’application Bookinfo se compose de quatre microservices distincts ayant les relations suivantes :

pageproduit. Le microservice de la page produit appelle les microservices de détails et d’avis pour remplir la page.
détails. Le microservice details contient des informations sur les livres.
reviews. Le microservice « critiques » contient des critiques de livres. Il fait également appel au microservice de notation.

évaluations. Le microservice « évaluations » contient des informations sur le classement des livres qui accompagnent les critiques littéraires.

Créer l’application exemple.


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

Vérifiez que l’application fonctionne correctement et notez l’adresse IP du pod pour le microservice pageproduit. Vous utiliserez cette adresse IP du pod pour interroger chaque microservice dans les étapes suivantes.


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

Créez un pod qui sera utilisé tout au long du processus pour tester les politiques réseau. Notez que le pod est créé dans l’espace de noms default avec le label 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

Testez l’accès au microservice de la page produit. Dans l’exemple ci-dessous, nous utilisons l’adresse IP du pod productpage (10.86.2.193) pour interroger le microservice. Remplacez ceci par l’adresse IP du pod productpage dans votre environnement.
```
curl -s http://10.86.2.193:9080/productpage | grep -o "<title>.*</title>"
```
```
<title>Simple Bookstore App</title>
```
Vous pouvez quitter le pod test curl en tapant exit et vous pouvez vous reconnecter au pod en exécutant la commande suivante.
```
kubectl attach curl-pod -c curl-pod -i -t
```

Pour démontrer les effets des stratégies réseau dans les étapes suivantes, nous créons d’abord une stratégie réseau qui refuse tout trafic pour les microservices BookInfo. Créez un fichier nommé network-policy-deny-bookinfo.yaml qui définit la stratégie réseau de refus.


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

Appliquez la stratégie réseau de refus à votre cluster.


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

Testez l’accès à l’application BookInfo. Dans l’exemple ci-dessous, nous utilisons l’adresse IP du pod productpage (10.86.2.193) pour interroger le microservice. Remplacez ceci par l’adresse IP du pod productpage dans votre environnement.
```
curl http://10.86.2.193:9080/productpage --max-time 10
```
```
curl: (28) Connection timed out after 10001 milliseconds
```

Créez un fichier nommé network-policy-productpage.yaml qui définit la politique réseau de la page produit. La politique prévoit les règles suivantes :

autorise le trafic entrant provenant des pods portant le label access: true (le pod curl créé à l’étape précédente)
autorise le trafic TCP sortant sur le port 9080 pour les microservices détaillant les informations, les avis et les évaluations

autorise le trafic TCP/UDP sortant sur le port 53 pour CoreDNS qui s’exécute dans l’espace de noms 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

Appliquez la stratégie réseau de la page produit à votre cluster.
```
kubectl apply -f network-policy-productpage.yaml
```

Connectez-vous au pod curl et testez l’accès à l’application Bookinfo. L’accès au microservice de la page produit est désormais autorisé, mais les autres microservices sont toujours refusés, car ils sont toujours soumis à la politique réseau de refus. Dans les exemples ci-dessous, nous utilisons l’adresse IP du pod productpage (10.86.2.193) pour interroger le microservice. Remplacez ceci par l’adresse IP du pod productpage dans votre environnement.


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

Créez un fichier nommé network-policy-details.yaml qui définit les détails de la stratégie réseau. La politique autorise uniquement le trafic entrant provenant du microservice 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

Créez un fichier nommé network-policy-reviews.yaml qui définit la politique réseau des avis. La politique autorise uniquement le trafic entrant provenant du microservice productpage et uniquement le trafic sortant vers le microservice ratings et 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

Créez un fichier nommé network-policy-ratings.yaml qui définit la politique du réseau de notation. La politique autorise uniquement le trafic entrant provenant des microservices de la page produit et des avis.


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

Appliquez les politiques réseau relatives aux détails, aux avis et aux évaluations à votre cluster.


kubectl apply -f network-policy-details.yaml
kubectl apply -f network-policy-reviews.yaml
kubectl apply -f network-policy-ratings.yaml

Connectez-vous au pod curl et testez l’accès à l’application Bookinfo. Dans les exemples ci-dessous, nous utilisons l’adresse IP du pod productpage (10.86.2.193) pour interroger le microservice. Remplacez ceci par l’adresse IP du pod productpage dans votre environnement.


kubectl attach curl-pod -c curl-pod -i -t

Testez les détails du microservice.


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

Testez le microservice des évaluations.


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

Testez le microservice de notation.


curl -s http://10.86.2.193:9080/api/v1/products/1/ratings


{"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}

Nettoyez les ressources que vous avez créées au cours de cette procédure.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Configurer les services LoadBalancer

Fonctionnement