Politiques de sécurité Kubernetes

Guide complet pour implémenter NetworkPolicy, PodSecurityPolicy, RBAC et Pod Security Standards dans Kubernetes.

Objectif

Implémenter une sécurité en profondeur pour les clusters Kubernetes en utilisant des politiques réseau, des standards de sécurité des pods et RBAC.

Quand utiliser cette compétence

Implémenter la segmentation réseau
Configurer les standards de sécurité des pods
Mettre en place RBAC pour un accès avec privilèges minimum
Créer des politiques de sécurité pour la conformité
Implémenter le contrôle d'admission
Sécuriser les clusters multi-locataires

Pod Security Standards

1. Privileged (Sans restrictions)

apiVersion: v1
kind: Namespace
metadata:
  name: privileged-ns
  labels:
    pod-security.kubernetes.io/enforce: privileged
    pod-security.kubernetes.io/audit: privileged
    pod-security.kubernetes.io/warn: privileged

2. Baseline (Minimalement restrictif)

apiVersion: v1
kind: Namespace
metadata:
  name: baseline-ns
  labels:
    pod-security.kubernetes.io/enforce: baseline
    pod-security.kubernetes.io/audit: baseline
    pod-security.kubernetes.io/warn: baseline

3. Restricted (Plus restrictif)

apiVersion: v1
kind: Namespace
metadata:
  name: restricted-ns
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted

Politiques réseau

Refuser tout par défaut

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

Autoriser le frontend vers le backend

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080

Autoriser DNS

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

Référence : Voir assets/network-policy-template.yaml

Configuration RBAC

Role (portée namespace)

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: production
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "watch", "list"]

ClusterRole (cluster entier)

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: secret-reader
rules:
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get", "watch", "list"]

RoleBinding

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: production
subjects:
  - kind: User
    name: jane
    apiGroup: rbac.authorization.k8s.io
  - kind: ServiceAccount
    name: default
    namespace: production
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Référence : Voir references/rbac-patterns.md

Contexte de sécurité des pods

Pod sécurisé

apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 1000
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: app
      image: myapp:1.0
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
            - ALL

Application de politiques avec OPA Gatekeeper

ConstraintTemplate

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8srequiredlabels
spec:
  crd:
    spec:
      names:
        kind: K8sRequiredLabels
      validation:
        openAPIV3Schema:
          type: object
          properties:
            labels:
              type: array
              items:
                type: string
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8srequiredlabels
        violation[{"msg": msg, "details": {"missing_labels": missing}}] {
          provided := {label | input.review.object.metadata.labels[label]}
          required := {label | label := input.parameters.labels[_]}
          missing := required - provided
          count(missing) > 0
          msg := sprintf("missing required labels: %v", [missing])
        }

Constraint

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sRequiredLabels
metadata:
  name: require-app-label
spec:
  match:
    kinds:
      - apiGroups: ["apps"]
        kinds: ["Deployment"]
  parameters:
    labels: ["app", "environment"]

Sécurité Service Mesh (Istio)

PeerAuthentication (mTLS)

apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: production
spec:
  mtls:
    mode: STRICT

AuthorizationPolicy

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-frontend
  namespace: production
spec:
  selector:
    matchLabels:
      app: backend
  action: ALLOW
  rules:
    - from:
        - source:
            principals: ["cluster.local/ns/production/sa/frontend"]

Bonnes pratiques

Implémenter Pod Security Standards au niveau du namespace
Utiliser Network Policies pour la segmentation réseau
Appliquer RBAC avec privilèges minimum pour tous les comptes de service
Activer le contrôle d'admission (OPA Gatekeeper/Kyverno)
Exécuter les conteneurs en tant qu'utilisateur non-root
Utiliser un système de fichiers racine en lecture seule
Supprimer toutes les capacités sauf si nécessaire
Implémenter des quotas de ressources et des limites de plage
Activer la journalisation d'audit pour les événements de sécurité
Analyse de sécurité régulière des images

Cadres de conformité

CIS Kubernetes Benchmark

Utiliser l'autorisation RBAC
Activer la journalisation d'audit
Utiliser Pod Security Standards
Configurer les politiques réseau
Implémenter le chiffrement des secrets au repos
Activer l'authentification des nœuds

NIST Cybersecurity Framework

Implémenter la défense en profondeur
Utiliser la segmentation réseau
Configurer la surveillance de sécurité
Implémenter les contrôles d'accès
Activer la journalisation et la surveillance

Dépannage

NetworkPolicy ne fonctionne pas :

# Vérifier si le CNI prend en charge NetworkPolicy
kubectl get nodes -o wide
kubectl describe networkpolicy <name>

Permission refusée RBAC :

# Vérifier les permissions effectives
kubectl auth can-i list pods --as system:serviceaccount:default:my-sa
kubectl auth can-i '*' '*' --as system:serviceaccount:default:my-sa

Compétences associées

k8s-manifest-generator - Pour créer des manifestes sécurisés
gitops-workflow - Pour le déploiement automatisé de politiques

k8s-security-policies