Container Service for Kubernetes:Use network policies in ACK clusters

Nouveaux clusters

Lors de la création d'un cluster, sélectionnez Support for NetworkPolicies pour activer la fonctionnalité de politique réseau. Pour plus d'informations, consultez la rubrique Créer un cluster ACK Pro.

Clusters existants

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Components and Add-ons .

3. Sous l'onglet Networking, localisez le module complémentaire terway-eniip et cliquez sur Configuration en bas à droite. Sélectionnez Enables NetworkPolicy puis cliquez sur OK.

   

   Important

   Pour les clusters dont DataPath V2 n'est pas activé, l'activation de la fonctionnalité NetworkPolicy ne prend pas effet immédiatement sur les nœuds existants. Vous devez redémarrer les nœuds pour que les modifications soient appliquées.

Utiliser la console

1. Créez une politique réseau pour le service Nginx. Pour plus d'informations sur les configurations, consultez la section Restreindre l'accès au service aux applications portant des libellés spécifiques à l'aide d'une politique réseau.

2. Dans la colonne External Endpoint de la liste des services, repérez l'adresse d'accès public (47.xxx.xx.x) pour le service de l'application exemple Nginx et accédez-y via un navigateur.

   L'accès échoue car la politique réseau refuse l'accès par défaut.

3. Ajoutez un bloc CIDR autorisé à la politique réseau pour permettre l'accès client.

   1. Visitez myip.ipip.net dans un navigateur pour obtenir l'adresse IP publique de votre machine.

   2. Dans la liste des politiques réseau, recherchez la politique réseau access-nginx, cliquez sur Edit dans la colonne Actions, et modifiez la règle dans le panneau Edit.

      À droite de Source, cliquez sur + Add et procédez comme suit :

      • À droite de Rule, cliquez sur + Add. Configurez la nouvelle règle pour autoriser l'accès depuis l'adresse IP de votre machine :

        Paramètre	Exemple
        Sélecteur	ipBlock
        cidr	<Adresse IP de votre machine>/32 Par exemple, 42.xx.xx.xx/32

      • À droite de Rule, cliquez sur + Add. Configurez la règle pour autoriser l'accès depuis le bloc CIDR de vérification d'état (health check) d'Alibaba Cloud SLB :

        Paramètre	Exemple
        Sélecteur	ipBlock
        cidr	100.0.0.0/8

      • À droite de Port, cliquez sur + Add et configurez le port comme suit :

        Paramètre	Exemple
        Protocole	TCP
        Port	80

      

   3. Cliquez sur Next puis sur OK.

   4. Dans la colonne External Endpoint de la liste des services, cliquez sur l'adresse IP du point de terminaison externe (47.xxx.xx.x:80) pour accéder au service Nginx.

      

      Après modification de la politique réseau, le client peut accéder au service Nginx via le SLB exposé sur Internet.

Utiliser la CLI

1. Exécutez la commande suivante pour créer une instance Alibaba Cloud SLB pour l'application nginx. Spécifiez type=LoadBalancer pour exposer le service nginx sur Internet.

   vim nginx-service.yaml

   Voici le modèle pour le fichier nginx-service.yaml.

   # Paste the following YAML content into nginx-service.yaml.
   apiVersion: v1
   kind: Service
   metadata:
     labels:
       run: nginx
     name: nginx-slb
   spec:
     externalTrafficPolicy: Local
     ports:
     - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       run: nginx
     type: LoadBalancer

   Exécutez la commande suivante pour créer une politique réseau à partir du fichier nginx-service.yaml.

   kubectl apply -f nginx-service.yaml 

   Sortie attendue :

   service/nginx-slb created

   Vérifiez si l'application expose le service Nginx :

   kubectl get service nginx-slb

   Sortie attendue :

   NAME        TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE
   nginx-slb   LoadBalancer   172.19.xx.xxx   47.110.xxx.xxx   80:32240/TCP   8m

2. Exécutez la commande suivante pour accéder à l'adresse IP de l'instance SLB nouvellement créée, 47 110.xxx.xxx. L'accès échoue.

   wget 47.110.xxx.xxx

   Sortie attendue :

   --2018-11-21 11:46:05--  http://47.110.xx.xxx/
   Connecting to 47.110.XX.XX:80... failed: Connection refused.

   Remarque

   L'accès échoue pour les raisons suivantes :

   • Le service nginx configuré ne peut être accédé que par les applications portant le libellé spécifique access=true.

   • L'accès à l'adresse IP de l'instance SLB est considéré comme un accès externe à Kubernetes. Cela diffère du scénario de restriction d'accès au service aux applications portant des libellés spécifiques.

   Solution : Modifiez la politique réseau pour ajouter le bloc CIDR source autorisé.

3. Exécutez la commande suivante pour afficher votre adresse IP locale.

   curl myip.ipip.net

   Sortie attendue :

   Current IP: 10.0.x.x From: China Beijing Beijing        # This is an example. Use the actual device information.

4. Exécutez la commande suivante pour modifier le fichier policy.yaml.

   vim policy.yaml

   Modifiez le fichier policy.yaml pour inclure le contenu suivant :

   # The following is the content of the YAML file.
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     name: access-nginx
   spec:
     podSelector:
       matchLabels:
         run: nginx
     ingress:
     - from:
       - podSelector:
           matchLabels:
             access: "true"
       - ipBlock:
           cidr: 100.64.0.0/10
       - ipBlock:
           cidr: 10.0.0.1/24      # Local IP address. This is an example. Use the actual device information.

   Exécutez la commande suivante pour créer une politique réseau à partir du fichier policy.yaml.

   kubectl apply -f policy.yaml 

   Sortie attendue :

   networkpolicy.networking.k8s.io/access-nginx unchanged

   Remarque

   • Certains réseaux possèdent plusieurs adresses IP de sortie. Nous vous recommandons d'utiliser une plage d'adresses /24.

   • Les adresses de vérification d'état (health check) du SLB se trouvent dans le bloc CIDR 100.64.0.0/10. Par conséquent, vous devez ajouter 100.64.0.0/10 à la liste des autorisations.

5. Exécutez la commande suivante pour accéder au service Nginx.

   kubectl run busybox --rm -ti --labels="access=true" --image=busybox /bin/sh

   Accédez au service nginx :

   wget 47.110.XX.XX

   Sortie attendue :

   Connecting to 47.110.XX.XX (47.110.XX.XX:80)
   index.html           100% |***********************************************************|   612  0:00:00 ETA

   La sortie indique que la progression de la connexion est de 100 %. Cela signifie que vous avez accédé avec succès au service Nginx.

Utiliser la console

Cette section utilise www.aliyun.com et registry.aliyuncs.com comme exemples pour illustrer la configuration d'une politique réseau autorisant un pod à accéder uniquement à registry.aliyuncs.com.

1. Exécutez la commande ping pour obtenir l'adresse IP (120.55.XXX.XXX) vers laquelle registry.aliyuncs.com se résout.

2. Créez une règle de politique réseau limitant l'accès de l'application busybox à registry.aliyuncs.com uniquement.

   1. Dans le coin supérieur gauche de la page Network Policies, cliquez sur Create et configurez la règle de politique réseau dans le panneau Create.

   Pour plus d'informations sur les paramètres, consultez la rubrique Restreindre l'accès aux services des applications portant des libellés spécifiques à l'aide d'une politique réseau. Voici un exemple de configuration.

   Paramètre	Description	Exemple
   Name	Nom personnalisé de la politique réseau.	busybox-policy
   Pod Selectors	Cliquez sur + Specify workload type and labels pour définir les pods auxquels s'applique la politique réseau. Remarque Si le sélecteur de pod est vide, la politique réseau s'applique à tous les pods du namespace.	Cet exemple utilise les paramètres suivants : Définissez Type sur Deployments Définissez Workloads sur busybox Définissez Labels sur app=busybox
   Destination	À droite de Destination, cliquez sur + Add, puis à droite de Rule, cliquez sur + Add. Ajoutez une règle pour ipBlock avec l'adresse IP résolue (120.55.XXX.XXX)/32 de registry.aliyuncs.com obtenue précédemment.	Selector : ipBlock cidr : 120,55.XXX.XXX/32
   	À droite de Destination, cliquez sur + Add. Ajoutez une règle autorisant l'accès au port UDP 53 pour tous les namespaces afin de garantir la résolution DNS de l'application. À droite de Rule, cliquez sur + Add. Ajoutez une règle sélectionnant tous les namespaces. À droite de Port, cliquez sur + Add. Ajoutez une règle pour UDP 53 afin de permettre la résolution DNS par l'application.	Rule : Selector : namespaceSelector Namespace : All Port : Protocol : UDP Port : 53

   2. Cliquez sur Next puis sur OK.

   3. Dans le terminal busybox, exécutez les commandes suivantes pour accéder à www.aliyun.com et à registry.aliyuncs.com.

      nc -vz -w 1 www.aliyunc.com 443

      nc -vz -w 1 registry.aliyuncs.com 443

      La sortie indique qu'après l'ajout de la politique réseau, l'application busybox peut accéder uniquement à registry.aliyuncs.com et ne peut pas atteindre d'autres adresses.

Utiliser la CLI

1. Exécutez la commande suivante pour obtenir la liste des adresses IP vers lesquelles le nom de domaine www.aliyun.com se résout.

   dig +short www.aliyun.com

   Sortie attendue :

   www-jp-de-intl-adns.aliyun.com.
   www-jp-de-intl-adns.aliyun.com.gds.alibabadns.com.
   v6wagbridge.aliyun.com.
   v6wagbridge.aliyun.com.gds.alibabadns.com.
   106.XX.XX.21
   140.XX.XX.4
   140.XX.XX.13
   140.XX.XX.3

2. Créez un fichier nommé busybox-policy.yaml.

   vim busybox-policy.yaml

   Utilisez le modèle suivant pour le fichier busybox-policy.yaml :

   # The following is the content of the YAML file.
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     name: busybox-policy
   spec:
     podSelector:
       matchLabels:
         run: busybox
     egress:
     - to:
       - ipBlock:
           cidr: 106.XX.XX.21/32
       - ipBlock:
           cidr: 140.XX.XX.4/32
       - ipBlock:
           cidr: 140.XX.XX.13/32
       - ipBlock:
           cidr: 140.XX.XX.3/32
     - to:
       - ipBlock:
           cidr: 0.0.0.0/0
       - namespaceSelector: {}
       ports:
       - protocol: UDP
         port: 53

   Remarque

   Dans le fichier busybox-policy.yaml, les règles egress restreignent l'accès sortant de l'application. Vous devez configurer les règles pour autoriser les requêtes UDP, faute de quoi la résolution DNS échouera.

3. Exécutez la commande suivante pour créer une politique réseau à partir du fichier busybox-policy.yaml.

   kubectl apply -f busybox-policy.yaml 

   Sortie attendue :

   networkpolicy.networking.k8s.io/busybox-policy created

4. Exécutez la commande suivante pour créer un pod busybox et tester l'accès.

   kubectl run busybox --rm -ti --image=busybox /bin/sh

   Accédez à un site web autre que www.aliyun.com, par exemple www.taobao.com :

   wget www.taobao.com

   Sortie attendue :

   Connecting to www.taobao.com (64.13.XX.XX:80)
   wget: can't connect to remote host (64.13.XX.XX): Connection timed out

   Le message can't connect to remote host indique un échec de connexion.

5. Exécutez la commande suivante pour accéder à www.aliyun.com.

   wget www.aliyun.com

   Sortie attendue :

   Connecting to www.aliyun.com (140.205.XX.XX:80)
   Connecting to www.aliyun.com (140.205.XX.XX:443)
   wget: note: TLS certificate validation not implemented
   index.html           100% |***********************************************************|  462k  0:00:00 ETA

   La sortie indique une progression de la connexion à 100 %, ce qui signifie que l'accès au service a réussi.

Utiliser la console

1. Dans le coin supérieur gauche de la page Network Policies, cliquez sur Create et configurez la règle de politique réseau dans le panneau Create.

   Pour plus d'informations sur les paramètres et les opérations, consultez la rubrique Restreindre l'accès aux services des applications portant des libellés spécifiques à l'aide d'une politique réseau. Voici un exemple de configuration.

   Paramètre	Exemple
   Name	deny-public-net
   Pod Selectors	Définissez Type sur All.
   Source	Ajoutez les deux règles suivantes : Définissez une règle autorisant tout pour namespaceSelector. Définissez une règle autorisant tout pour ipBlock.
   Destination	Ajoutez une règle n'autorisant l'accès qu'au réseau interne : Définissez une règle autorisant All pour namespaceSelector afin de permettre au pod d'accéder à tous les pods du réseau interne. Définissez trois règles pour ipBlock correspondant aux trois blocs CIDR du réseau interne suivants : 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 Remarque Vous ne pouvez pas ajouter plusieurs blocs CIDR dans une seule règle ipBlock.

2. Cliquez sur Next puis sur OK.

3. Sur l'onglet Basic Information de la page des détails du cluster, obtenez l'adresse IP interne et le port du serveur API.

   

4. Dans le terminal busybox, exécutez les commandes suivantes pour tester l'accès du pod aux réseaux public et interne.

   nc -vz -w 1 www.aliyunc.com 443

   nc -vz -w 1 10.xx.xx.xx:<IP port> # This is your internal IP address.

   La sortie montre que le pod peut accéder uniquement aux adresses internes et non aux adresses publiques.

Utiliser la CLI

1. Exécutez la commande suivante pour créer un namespace de test.

   Créez un namespace nommé test-np.

   kubectl create ns test-np

   Sortie attendue :

   namespace/test-np created

2. Exécutez la commande suivante pour créer une politique réseau par défaut pour le namespace, n'autorisant que l'accès sortant vers les réseaux privés.

   vim default-deny.yaml

   Voici un exemple de modèle pour le fichier default-deny.yaml :

   # The following is the content of the YAML file.
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     namespace: test-np
     name: deny-public-net
   spec:
     podSelector: {}
     ingress:
     - from:
       - ipBlock:
           cidr: 0.0.0.0/0
     egress:
     - to:
       - ipBlock:
           cidr: 192.168.0.0/16
       - ipBlock:
           cidr: 172.16.0.0/12
       - ipBlock:
           cidr: 10.0.0.0/8

   Vérifiez que le fichier default-deny.yaml a été créé.

   kubectl apply -f default-deny.yaml

   Sortie attendue :

   networkpolicy.networking.k8s.io/deny-public-net created

   Affichez la politique réseau :

   kubectl get networkpolicy -n test-np

   Sortie attendue :

   NAME                              POD-SELECTOR          AGE
   deny-public-net                   <none>                1m

3. Exécutez la commande suivante pour créer une politique réseau permettant aux pods portant un libellé spécifique d'accéder au réseau public.

   vim allow-specify-label.yaml

   Dans cet exemple, le libellé est public-network=true.

   # The following is the content of the YAML file.
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     name: allow-public-network-for-labels
     namespace: test-np
   spec:
     podSelector:
       matchLabels:
         public-network: "true"
     ingress:
     - from:
       - ipBlock:
           cidr: 0.0.0.0/0
     egress:
     - to:
       - ipBlock:
           cidr: 0.0.0.0/0
       - namespaceSelector:
           matchLabels:
             ns: kube-system  # Allows pods to access key services in kube-system (such as CoreDNS). This is an example. Configure as needed. 

   Exécutez la commande suivante pour créer la politique réseau :

   kubectl apply -f allow-specify-label.yaml

   Sortie attendue :

   networkpolicy.networking.k8s.io/allow-public-network-for-labels created

   Affichez la politique réseau :

   kubectl get networkpolicy -n test-np

   Sortie attendue :

   NAME                              POD-SELECTOR          AGE
   allow-public-network-for-labels   public-network=true    1m
   deny-public-net                   <none>                 3m

4. Exécutez les commandes suivantes pour vérifier qu'un pod sans le libellé spécial ne peut pas accéder au réseau public.

   kubectl run -it --namespace test-np --rm --image registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/busybox:1.28 busybox-intranet

   ping aliyun.com

   Sortie attendue :

   PING aliyun.com (106.11.2xx.xxx): 56 data bytes
   ^C
   --- aliyun.com ping statistics ---
   9 packets transmitted, 0 packets received, 100% packet loss

   Le message 0 packets received indique un échec de connexion.

   Remarque

   L'échec de connexion s'explique par la politique réseau deny-public-net qui restreint par défaut l'accès au réseau public pour les pods du namespace test-np. Par conséquent, les pods démarrés dans ce namespace avec des libellés par défaut ne peuvent pas accéder au réseau public.

5. Exécutez la commande suivante pour vérifier qu'un pod portant le libellé public-network=true peut accéder au réseau public.

   kubectl run -it --namespace test-np --labels public-network=true --rm --image registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/busybox:1.28 busybox-internet

   ping aliyun.com

   Sortie attendue :

   PING aliyun.com (106.11.1xx.xx): 56 data bytes
   64 bytes from 106.11.1xx.xx: seq=0 ttl=47 time=4.235 ms
   64 bytes from 106.11.1xx.xx: seq=1 ttl=47 time=4.200 ms
   64 bytes from 106.11.1xx.xx: seq=2 ttl=47 time=4.182 ms
   ^C
   --- aliyun.com ping statistics ---
   3 packets transmitted, 3 packets received, 0% packet loss
   round-trip min/avg/max = 4.182/4.205/4.235 ms

   Le message 0 % packet loss indique que l'accès au service a réussi.

   Remarque

   L'accès réussit car la politique réseau allow-public-network-for-labels autorise l'accès au réseau public pour les pods portant le libellé public-network=true. Ainsi, le pod busybox-internet, qui possède ce libellé, peut accéder au réseau public.