Configurer une règle de réseau

Cette page explique comment utiliser les règles de réseau des clusters pour contrôler si un pod peut recevoir du trafic réseau entrant (Ingress) et s'il peut envoyer du trafic sortant (Egress).

Les règles de réseau vous permettent de limiter les connexions entre les objets de pod afin de réduire l'exposition aux attaques.

Les règles de réseau agissent comme un pare-feu sur la couche 3 ou la couche 4 du modèle OSI. Elles n'offrent pas de fonctionnalités supplémentaires telles que l'autorisation ou le chiffrement.

Limiter le trafic entrant vers les objets de pod

Un objet NetworkPolicy vous permet de configurer des règles d'accès au réseau pour un pod. Les objets NetworkPolicy contiennent les informations suivantes :

  • Les objets de pod auxquels la règle s'applique. Vous définissez les objets et les charges de travail de pod à l'aide d'étiquettes et de sélecteurs.

  • Le type de trafic affecté par la règle de réseau : Ingress pour le trafic entrant, Egress pour le trafic sortant, ou les deux.

  • Pour les règles d'entrée, les objets de pod qui peuvent se connecter aux objets de pod spécifiés.

  • Pour les règles de sortie, les objets de pod auxquels les objets de pod spécifiés peuvent se connecter.

Exemple de restriction du trafic entrant

Cette section illustre la création d'une restriction de trafic entrant sur un exemple d'application. Modifiez cet exemple pour l'adapter à votre propre environnement d'application.

  1. Exécutez une application de serveur Web qui porte l'étiquette app=hello, puis exposez-la en interne dans le cluster :

    kubectl run hello-web --labels app=hello \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 \
    --port 8080 --expose

  2. Configurez un objet NetworkPolicy pour autoriser le trafic vers le pod hello-web provenant seulement des objets de pod app=foo. GKE sur Azure bloque le trafic entrant des objets de pod ne comportant pas cette étiquette, ainsi que le trafic externe, et le trafic provenant d'objets de pod situés dans un espace de noms différent.

    Le fichier manifeste suivant sélectionne les objets de pod qui portent l'étiquette app=hello et spécifie une règle d'entrée pour autoriser le trafic provenant seulement des objets de pod qui portent l'étiquette app=foo :

    kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: hello-allow-from-foo
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: hello
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: foo

  3. Appliquez cette règle au cluster :

    kubectl apply -f hello-allow-from-foo.yaml

Valider la règle d'entrée

  1. Exécutez un pod temporaire qui porte l'étiquette app=foo. Pour vérifier que le trafic entrant est autorisé, envoyez une requête au point de terminaison hello-web:8080 :

    kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t foo-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    Si le trafic provenant du pod app=foo vers les objets de pod app=hello est activé, la sortie ressemble à ceci :

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  2. Exécutez un pod temporaire associé à une autre étiquette (app=other), puis envoyez la même requête pour constater que le trafic n'est pas autorisé :

    kubectl run -l app=other --image=alpine --restart=Never --rm -i -t other-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    La sortie confirme que la connexion ne reçoit pas de réponse :

    wget: download timed out

Limiter le trafic sortant des objets de pod

Vous pouvez limiter le trafic sortant comme vous le feriez pour le trafic entrant.

Cependant, pour interroger des noms d'hôte internes tels que hello-web ou des noms d'hôte externes tels que www.example.com, vous devez créer une règle de sortie qui autorise le trafic DNS sur le port 53 utilisant les protocoles TCP et UDP.

Pour activer les règles de réseau de sortie, déployez une règle NetworkPolicy contrôlant le trafic sortant des objets de pod qui portent l'étiquette app=foo, tout en n'autorisant le trafic que vers les objets de pod qui portent l'étiquette app=hello, ainsi que le trafic DNS.

Le fichier manifeste suivant spécifie une règle NetworkPolicy contrôlant le trafic de sortie des objets de pod qui portent l'étiquette app=foo vers deux destinations autorisées :

  1. Les objets de pod dans le même espace de noms qui portent l'étiquette app=hello
  2. Les points de terminaison internes ou externes sur le port 53 (UDP et TCP)
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: foo-allow-to-hello
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: foo
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: hello
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP

Appliquez cette règle au cluster :

kubectl apply -f foo-allow-to-hello.yaml

Valider la règle de sortie

  1. Déployez une nouvelle application Web nommée hello-web-2, puis exposez-la en interne dans le cluster :

    kubectl run hello-web-2 --labels app=hello-2 \
  --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080 --expose

  2. Exécutez un pod temporaire qui porte l'étiquette app=foo, puis vérifiez qu'il peut établir des connexions à hello-web:8080 :

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
  -- wget -qO- --timeout=2 http://hello-web:8080

    Le pod répond à la requête :

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  3. Confirmez que le pod ne peut pas établir de connexions à hello-web-2:8080 :

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://hello-web-2:8080

    La sortie confirme que la connexion ne reçoit pas de réponse :

    wget: download timed out

  4. Confirmez que le pod ne peut pas établir de connexions vers des sites Web externes tels que www.example.com.

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://www.example.com

    La sortie confirme que la connexion ne reçoit pas de réponse :

    wget: download timed out

Effectuer un nettoyage

Pour supprimer les ressources que vous avez créées dans ce tutoriel, exécutez ces commandes :

kubectl delete pods --labels app=hello-2
kubectl delete pods --labels app=hello
kubectl delete -f foo-allow-to-hello.yaml
kubectl delete -f hello-allow-from-foo.yaml

Étape suivante