Container Service for Kubernetes:Sécurité réseau

Approche recommandée : refus par défaut, puis autorisation

Appliquez le principe du moindre privilège : refusez tout le trafic par défaut, puis ajoutez des règles pour n'autoriser que le trafic nécessaire à chaque charge de travail.

1. Créez une politique de refus par défaut -- Bloquez tout le trafic entrant et sortant dans le namespace.

2. Autorisez les requêtes DNS -- Les pods ont besoin de la résolution DNS pour fonctionner.

3. Autorisez le trafic spécifique -- N'ouvrez que les chemins requis par chaque charge de travail.

Étape 1 : Créer une politique de refus par défaut

Créez une politique réseau pour refuser tout le trafic entrant et sortant dans un namespace, ou utilisez Calico pour une politique globale.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

Étape 2 : Autoriser les requêtes DNS

Avec une politique de refus par défaut, les pods ne peuvent pas résoudre les noms DNS. Créez une politique pour autoriser les requêtes DNS vers CoreDNS.

1. Ajoutez un libellé au namespace kube-system :

      kubectl label namespace kube-system name=kube-system

2. Créez une politique réseau pour autoriser le trafic sortant vers CoreDNS sur le port UDP 53 :

      apiVersion: networking.k8s.io/v1
      kind: NetworkPolicy
      metadata:
        name: allow-dns-access
        namespace: default
      spec:
        podSelector:
          matchLabels: {}
        policyTypes:
        - Egress
        egress:
        - to:
          - namespaceSelector:
              matchLabels:
                name: kube-system
          ports:
          - protocol: UDP
            port: 53

Étape 3 : Autoriser le trafic provenant de pods spécifiques

Une fois les politiques de refus et DNS en place, n'autorisez le trafic qu'en provenance des pods autorisés. Cas d'utilisation courants :

• Autoriser uniquement certains microservices à accéder à une application.

• Autoriser uniquement certaines applications à accéder à une base de données.

Cet exemple crée un pod et restreint le trafic entrant aux pods portant le libellé app: bookstore.

1. Créez un pod avec les libellés app=bookstore et role=api :

      kubectl run apiserver --image=nginx --labels="app=bookstore,role=api" --expose --port=80

2. Appliquez une politique réseau qui n'autorise le trafic entrant qu'en provenance des pods portant le libellé app: bookstore :

      kind: NetworkPolicy
      apiVersion: networking.k8s.io/v1
      metadata:
        name: api-allow
      spec:
        podSelector:
          matchLabels:
            app: bookstore
            role: api
        ingress:
        - from:
            - podSelector:
                matchLabels:
                  app: bookstore

3. Vérifiez que les pods ne portant pas le libellé app=bookstore se voient refuser l'accès :

      kubectl run test-$RANDOM --rm -i -t --image=alpine -- sh

      / # wget -qO- --timeout=2 http://apiserver
      wget: download timed out

4. Vérifiez que les pods portant le libellé app=bookstore peuvent accéder au serveur :

      kubectl run test-$RANDOM --rm -i -t --image=alpine --labels="app=bookstore,role=frontend" -- sh

      / # wget -qO- --timeout=2 http://apiserver
      <!DOCTYPE html>
      <html><head>

Ajouter des règles personnalisées entre les pods d'un namespace

Après avoir autorisé la communication entre les pods au sein d'un namespace, utilisez les recettes de politiques réseau Kubernetes pour ajouter des règles personnalisées offrant un contrôle plus granulaire.