Configurer des règles de réseau pour les applications

Ce tutoriel explique comment utiliser les règles de réseau des clusters pour contrôler les pods qui reçoivent le trafic réseau entrant, ainsi que ceux qui peuvent envoyer du trafic sortant. Pour plus d'informations, consultez la page Créer une règle de réseau pour un cluster.

Les règles de réseau vous permettent de limiter les connexions entre les pods. Par conséquent, l'utilisation de règles de réseau offre une sécurité supérieure en réduisant le risque de problème de sécurité.

Notez que les règles de réseau déterminent si une connexion est autorisée et n'offrent pas de fonctionnalités de niveau supérieur, telles que l'autorisation ou le transport sécurisé (comme les certificats SSL/TLS).

Objectifs

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

  • Créer des clusters avec l'application de règles de réseau
  • Limiter le trafic entrant vers les pods à l'aide de libellés
  • Limiter le trafic sortant des pods à l'aide de libellés

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Pour activer l'API Kubernetes Engine, procédez comme suit :
  1. Accédez à la page Kubernetes Engine dans la console Google Cloud.
  2. Créer ou sélectionner un projet
  3. Patientez le temps de l'activation de l'API et des services associés. Cette opération peut prendre plusieurs minutes.

  4. Vérifiez que la facturation est activée pour votre projet Google Cloud.

Installez les outils de ligne de commande suivants utilisés dans ce tutoriel :

  • gcloud permet de créer et de supprimer des clusters Kubernetes Engine. gcloud est inclus dans la CLI gcloud.
  • kubectl permet de gérer Kubernetes, le système d'orchestration de clusters utilisé par Kubernetes Engine. Vous pouvez installer kubectl avec gcloud : 
    gcloud components install kubectl

Clonez l'exemple de code depuis GitHub :

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/networking/network-policies

Définir des valeurs par défaut pour l'outil de ligne de commande gcloud

Pour gagner du temps lors de la saisie de vos options d'ID de projet et de zone Compute Engine dans l'outil de ligne de commande gcloud, vous pouvez définir les valeurs par défaut suivantes :
gcloud config set project project-id
gcloud config set compute/zone compute-zone

Créer un cluster GKE avec l'application de règles de réseau

Pour créer un cluster de conteneurs avec l'application de règles de réseau, exécutez la commande suivante :

gcloud container clusters create test --enable-network-policy

Limiter le trafic entrant vers les pods

Les ressources NetworkPolicy Kubernetes vous permettent de configurer des règles d'accès au réseau pour les pods. Les objets NetworkPolicy contiennent les informations suivantes :

  • Les pods auxquels s'appliquent les règles de réseau, généralement désignés par un sélecteur de libellés

  • 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 pods qui peuvent se connecter aux pods spécifiés

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

Commencez par exécuter une application simple de serveur Web associée à 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

Configurez ensuite une règle de réseau (NetworkPolicy) pour autoriser le trafic vers les pods hello-web provenant uniquement des pods app=foo. Le reste du trafic entrant provenant de pods qui ne portent pas ce libellé, le trafic externe et le trafic provenant de pods situés dans d'autres espaces de noms sont bloqués.

Le fichier manifeste suivant sélectionne les pods portant l'étiquette app=hello et spécifie une règle d'entrée pour autoriser le trafic provenant seulement des pods portant 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

Pour appliquer cette règle au cluster, exécutez la commande suivante :

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

Valider la règle d'entrée

Tout d'abord, exécutez un pod temporaire portant l'étiquette app=foo, puis obtenez une interface système dans le pod :

kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t test-1

Envoyez une requête au point de terminaison hello-web:8080 pour vérifier que le trafic entrant est autorisé :

/ # wget -qO- --timeout=2 http://hello-web:8080
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z
/ # exit

Le trafic depuis le pod app=foo vers les pods app=hello est activé.

Exécutez ensuite un pod temporaire associé à une autre étiquette (app=other), puis obtenez une interface système à l'intérieur du pod :

kubectl run -l app=other --image=alpine --restart=Never --rm -i -t test-1

Envoyez la même requête pour constater que le trafic n'est pas autorisé et que, par conséquent, la demande expire, puis quittez l'interface système du pod :

/ # wget -qO- --timeout=2 http://hello-web:8080
wget: download timed out
/ # exit

Limiter le trafic sortant des pods

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

Toutefois, pour pouvoir 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 autoriser la résolution DNS (Domain Name System) dans vos règles de réseau de sortie. Le trafic DNS se produit sur le port 53 à l'aide des protocoles TCP et UDP.

Pour appliquer les règles de réseau de sortie, déployez une ressource NetworkPolicy contrôlant le trafic sortant des pods portant l'étiquette app=foo, tout en n'autorisant le trafic que vers les pods portant l'étiquette app=hello ainsi que le trafic DNS.

Le fichier manifeste suivant spécifie une règle de réseau contrôlant le trafic de sortie des pods portant l'étiquette app=foo avec deux destinations autorisées :

  1. Les pods situés dans le même espace de noms et portant l'étiquette app=hello
  2. Les pods du cluster ou les points de terminaison 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

Pour appliquer cette règle au cluster, exécutez la commande suivante :

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

Valider la règle de sortie

Commencez par déployer 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

Exécutez ensuite un pod temporaire portant l'étiquette app=foo, puis ouvrez une interface système à l'intérieur du conteneur :

kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never test-3

Confirmez que le pod peut établir des connexions à hello-web:8080 :

/ # wget -qO- --timeout=2 http://hello-web:8080
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

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

/ # wget -qO- --timeout=2 http://hello-web-2:8080
wget: download timed out

Confirmez que le pod ne peut pas établir de connexions à des sites Web externes tels que www.example.com, puis quittez l'interface système du pod.

/ # wget -qO- --timeout=2 http://www.example.com
wget: download timed out
/ # exit

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

  1. Supprimez le cluster de conteneurs : cette étape supprime les ressources qui constituent le cluster de conteneurs, telles que les instances de calcul, les disques et les ressources réseau.

    gcloud container clusters delete test

Étapes suivantes