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.

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 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 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 relatives à l'entrée et à la sortie des pods. AWS ne prend actuellement pas en charge CiliumNetworkPolicy ouCiliumClusterwideNetworkPolicy.
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 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 choisir 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 les adresses IP des nœuds est une fonctionnalité bêta de Cilium qui 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.

Conditions préalables

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 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 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' BookInfo application. 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 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 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