Aidez à améliorer cette page

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien Modifier cette page sur qui se trouve dans le volet droit de chaque page.

Configuration des 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 d'entrée et de sortie des pods lors de l'utilisation de Cilium comme CNI avec les nœuds hybrides EKS. Si vous utilisez des clusters EKS avec des nœuds dans le AWS cloud, AWS prend en charge les politiques réseau Amazon VPC CNI pour Kubernetes.

Cette rubrique explique comment configurer les politiques réseau de Cilium et Kubernetes avec les nœuds hybrides EKS. Pour des informations détaillées 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 relatives à l'entrée et à la sortie des pods. AWS ne prend actuellement pas en charge CiliumNetworkPolicy ouCiliumClusterwideNetworkPolicy.
La valeur policyEnforcementMode Helm peut être utilisée pour contrôler le comportement d'application de la politique par défaut de Cilium. Le comportement par défaut autorise tout le trafic entrant et sortant. Lorsqu'un point de terminaison est sélectionné par une politique réseau, il passe à un état de refus par défaut, dans lequel seul le trafic explicitement autorisé est autorisé. Consultez la documentation de Cilium pour plus d'informations sur le mode de politique par défaut et les modes d'application des politiques.
Si vous optez policyEnforcementMode pour une installation Cilium existante, vous devez redémarrer l'agent Cilium DaemonSet pour appliquer le nouveau mode d'application des politiques.
Utilisez namespaceSelector et podSelector pour autoriser ou refuser les to/from espaces de noms de trafic et les pods dotés d'étiquettes correspondantes. Le namespaceSelector et podSelector peut être utilisé avec matchLabels ou matchExpressions pour sélectionner des espaces de noms et des pods en fonction de leurs étiquettes.
Utilisez ingress.ports et egress.ports pour autoriser ou refuser to/from les ports et protocoles de trafic.
Le ipBlock champ ne peut pas être utilisé pour autoriser ou refuser de manière sélective les adresses IP du to/from module de trafic (#9209). L'utilisation de ipBlock sélecteurs pour le nœud IPs est une fonctionnalité bêta de Cilium et n'est pas prise en charge par. AWS
Consultez la NetworkPolicy ressource de la documentation Kubernetes pour plus d'informations sur les champs disponibles pour les politiques réseau Kubernetes.

Prérequis

Cilium a été installé en suivant les instructions fournies dans. Configurer le CNI pour les nœuds hybrides
Helm est installé dans votre environnement de ligne de commande, voir les instructions de configuration de Helm.

Procédure

La procédure suivante définit les politiques réseau pour un exemple d'application de microservices afin que les composants puissent uniquement communiquer avec les autres composants nécessaires au fonctionnement de l'application. La procédure utilise l'exemple d'application de microservices Istio Bookinfo.

L'application Bookinfo se compose de quatre microservices distincts présentant les relations suivantes :

page du produit. Le microservice productpage appelle les informations et passe en revue les microservices pour remplir la page.
détails. Le microservice Details contient des informations sur le livre.
critiques. Le microservice de critiques contient des critiques de livres. Il fait également appel au microservice de notation.

évaluations. Le microservice de notation contient des informations sur le classement des livres qui accompagnent une critique de livre.

Créez l'exemple d'application.


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

Vérifiez que l'application s'exécute correctement et notez l'adresse IP du module pour le microservice productpage. Vous utiliserez l'adresse IP de ce module pour interroger chaque microservice au cours des é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 module qui sera utilisé partout pour tester les politiques du réseau. Notez que le pod est créé dans l'espace de default noms avec l'étiquetteaccess: 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-la par l'adresse IP du module productpage de votre environnement.
```
curl -s http://10.86.2.193:9080/productpage | grep -o "<title>.*</title>"
```
```
<title>Simple Bookstore App</title>
```
Vous pouvez quitter le module test curl en tapant exit et vous reconnecter au module en exécutant la commande suivante.
```
kubectl attach curl-pod -c curl-pod -i -t
```

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


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 politique de refus du réseau à votre cluster.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
Testez l'accès à l' BookInfo application. Dans l'exemple ci-dessous, nous utilisons l'adresse IP du pod productpage (10.86.2.193) pour interroger le microservice. Remplacez-la par l'adresse IP du module productpage de 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 appelé network-policy-productpage.yaml qui définit la politique réseau de productpage. La politique comporte les règles suivantes :

autorise le trafic entrant depuis les pods portant l'étiquette access: true (le module curl créé à l'étape précédente)
autorise le trafic TCP de sortie sur le port 9080 pour les détails, les révisions et les évaluations des microservices

autorise le TCP/UDP trafic de sortie 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 politique réseau de productpage à votre cluster.
```
kubectl apply -f network-policy-productpage.yaml
```

Connectez-vous au module 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 de refus du réseau. Dans les exemples ci-dessous, nous utilisons l'adresse IP du pod productpage (10.86.2.193) pour interroger le microservice. Remplacez-la par l'adresse IP du module productpage de 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 appelé network-policy-details.yaml qui définit les détails de la politique réseau. La politique autorise uniquement le trafic entrant depuis le microservice de la page produit.


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 appelé network-policy-reviews.yaml qui définit la politique du réseau de révisions. La politique autorise uniquement le trafic entrant depuis le microservice de la page produit et uniquement le trafic sortant vers le microservice d'évaluation 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 appelé network-policy-ratings.yaml qui définit la politique du réseau de notation. La politique autorise uniquement le trafic entrant depuis la page du produit et examine les microservices.


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 du 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 module 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-la par l'adresse IP du module productpage de votre environnement.


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

Testez le microservice de détails.


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 d'avis.


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 LoadBalancer services

Comment ça marche