Progressez avec Kube-Score

Mise à jour : 21/09/2024

En tant que consultant DevOps, vous connaissez l’importance d’assurer la sécurité et la fiabilité des applications déployées sur Kubernetes. C’est là que kube-score, un outil d’analyse statique de code pour Kubernetes, entre en jeu.

Créé sous une licence MIT, cet outil open-source analyse vos définitions d’objets Kubernetes et génère une liste de conseils pour optimiser votre application. Il s’agit d’une étape fondamentale pour éviter les temps d’arrêt et les bugs, en assurant que vos configurations Kubernetes soient non seulement performantes, mais aussi sécurisées.

Installation de kube-score

L’installation de kube-score peut être effectuée facilement sur divers systèmes d’exploitation en utilisant les gestionnaires de paquets spécifiques à chaque plateforme. Voici comment procéder :

Sous Linux avec ASDF

ASDF est un gestionnaire de versions extensible pour Linux, qui permet de gérer plusieurs versions d’un grand nombre de logiciels. Pour installer kube-score avec ASDF, suivez ces instructions :

asdf plugin-add kube-score

# Installez la dernière version de kube-score
asdf install kube-score latest
asdf global kube-score latest

Sous MacOS avec Homebrew

Homebrew est un gestionnaire de paquets populaire pour MacOS. Il peut être utilisé pour installer kube-score de manière simple et efficace :

brew install kube-score

Vérification de l’installation

Il suffit de taper la commande suivante :

kube-score version
kube-score version: 1.17.0, commit: 0b3f154ca3f06a13323431a7d2199a74a1869fbc, built: 2023-07-06T07:43:29Z

Utiliser kube-score

Une fois que kube-score est installé sur votre système, l’utiliser est tout aussi simple. kube-score analyse les fichiers de définition d’objets Kubernetes et retourne une liste de recommandations. Voici comment exécuter kube-score et comprendre ses résultats.

Je vais utiliser cet exemple :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: monprojet
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx
        name: nginx

Pour exécuter kube-score, vous devez lui fournir des fichiers de configuration Kubernetes en YAML ou JSON. Vous pouvez utiliser soit des fichiers individuels, soit des répertoires contenant plusieurs fichiers. Voici un exemple de commande pour exécuter kube-score :

# Exécutez kube-score sur un fichier de configuration spécifique
kube-score score mon-deploiement.yaml

# Ou sur un répertoire contenant plusieurs fichiers de configuration
kube-score score mon_repertoire_de_configurations/

Interprétation des Résultats

kube-score retourne une liste de recommandations classées par importance. Chaque recommandation est accompagnée d’une note et d’une description détaillée. Les notes vont de “CRITICAL” pour les problèmes majeurs qui nécessitent une attention immédiate, à “WARNING” pour les problèmes moins urgents mais qui devraient être corrigés.

Voici un exemple de sortie de kube-score :

    [CRITICAL] Container Image Tag
        · nginx -> Image with latest tag
            Using a fixed tag is recommended to avoid accidental upgrades
    [CRITICAL] Pod NetworkPolicy
        · The pod does not have a matching NetworkPolicy
            Create a NetworkPolicy that targets this pod to control who/what can communicate with this pod. Note, this feature needs to be supported by the CNI
            implementation used in the Kubernetes cluster to have an effect.
    [CRITICAL] Container Resources
        · nginx -> CPU limit is not set
            Resource limits are recommended to avoid resource DDOS. Set resources.limits.cpu
        · nginx -> Memory limit is not set
            Resource limits are recommended to avoid resource DDOS. Set resources.limits.memory
        · nginx -> CPU request is not set
            Resource requests are recommended to make sure that the application can start and run without crashing. Set resources.requests.cpu
        · nginx -> Memory request is not set
            Resource requests are recommended to make sure that the application can start and run without crashing. Set resources.requests.memory
    [CRITICAL] Container Ephemeral Storage Request and Limit
        · nginx -> Ephemeral Storage limit is not set
            Resource limits are recommended to avoid resource DDOS. Set resources.limits.ephemeral-storage
    [CRITICAL] Container Security Context User Group ID
        · nginx -> Container has no configured security context
            Set securityContext to run the container in a more secure context.
    [CRITICAL] Container Security Context ReadOnlyRootFilesystem
        · nginx -> Container has no configured security context
            Set securityContext to run the container in a more secure context.
    [CRITICAL] Deployment has PodDisruptionBudget
        · No matching PodDisruptionBudget was found
            It's recommended to define a PodDisruptionBudget to avoid unexpected downtime during Kubernetes maintenance operations, such as when draining a
            node.
    [WARNING] Deployment has host PodAntiAffinity
        · Deployment does not have a host podAntiAffinity set
            It's recommended to set a podAntiAffinity that stops multiple pods from a deployment from being scheduled on the same node. This increases
            availability in case the node becomes unavailable.

Dans cet exemple, kube-score a identifié de nombreux problèmes critiques.

Agir sur les Recommandations

Une fois que vous avez les résultats, le but est d’agir sur ces recommandations. Par exemple, si kube-score que l’image utilisée n’est pas taguée. Ajoutons un tag et des ressources dans le fichier YAML :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: monprojet
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - image: nginx:1.25.3
          name: nginx
          resources:
            limits:
              cpu: "500m"
              memory: "500Mi"

En suivant ces étapes, vous pouvez utiliser kube-score pour analyser et améliorer la configuration de vos déploiements Kubernetes, augmentant ainsi leur fiabilité et leur sécurité.

Améliorations de Sécurité avec kube-score

L’utilisation de kube-score permet d’identifier et de corriger les vulnérabilités de sécurité dans les configurations Kubernetes. Dans cette section, je vais discuter de la manière dont kube-score contribue à renforcer la sécurité de vos applications.

kube-score vérifie plusieurs aspects de la sécurité des objets Kubernetes. Parmi les contrôles de sécurité les plus courants, on trouve :

Privilèges élevés de conteneurs : kube-score vérifie si les conteneurs s’exécutent avec des privilèges inutilement élevés, ce qui pourrait être une faille de sécurité majeure.
Contexte de Sécurité des Conteneurs : L’outil contrôle la configuration du contexte de sécurité de chaque conteneur, comme l’exécution en tant qu’utilisateur non-root, pour prévenir les accès non autorisés.
Politiques de Réseau : kube-score analyse si des politiques de réseau adéquates sont en place pour contrôler le trafic entrant et sortant des pods.

Reprenons l’analyse de l’exemple ci-dessus avec kube-score :

kube-score score /tmp/mon-deploiement.yaml
apps/v1/Deployment nginx-deployment in monprojet                              💥
    [CRITICAL] Container Security Context ReadOnlyRootFilesystem
        · nginx -> Container has no configured security context
            Set securityContext to run the container in a more secure context.
    [CRITICAL] Pod NetworkPolicy
        · The pod does not have a matching NetworkPolicy
            Create a NetworkPolicy that targets this pod to control who/what can communicate with this pod. Note, this feature needs to be supported by the CNI
            implementation used in the Kubernetes cluster to have an effect.
    [CRITICAL] Container Security Context User Group ID
        · nginx -> Container has no configured security context
            Set securityContext to run the container in a more secure context.

Dans cet exemple, kube-score a détecté que le conteneur s’exécute avec un ID utilisateur potentiellement dangereux et suggère de modifier le securityContext pour améliorer la sécurité.

Pour mettre en œuvre cette recommandation, vous devriez modifier votre fichier de configuration Kubernetes comme suit :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: monprojet
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - image: nginx:1.25.3
          name: nginx
          resources:
            limits:
              cpu: "500m"
              memory: "500Mi"
          securityContext:
            runAsUser: 101

En ajoutant la directive securityContext avec un runAsUser approprié, vous renforcez la sécurité du conteneur en vous assurant qu’il ne s’exécute pas avec des privilèges d’utilisateur élevés.

Appliquons :

kubectl apply -f mon-deploiement.yaml
deployment.apps/nginx-deployment configured

Vérifions notre déploiement :

kubectl get pods
NAME                                READY   STATUS             RESTARTS      AGE
pod-nginx                           1/1     Running            0             129m
pod-secret                          1/1     Running            0             101m
nginx-deployment-5db7d44b96-4vkl2   1/1     Running            0             8m37s
nginx-deployment-5db7d44b96-89b49   1/1     Running            0             8m34s
nginx-deployment-5445cd8ff4-kpjpl   0/1     CrashLoopBackOff   1 (14s ago)   16s

Mince, cela ne fonctionne pas ! Pourquoi ? Tout simplement l’image utilise le compte root, ce qui est courant dans de nombreux conteneurs disponibles dans les registries publiques.

Cela peut être dû à des exigences de port, des processus internes ou des permissions spécifiques. Dans ces cas, il est indispensable de comprendre les risques associés et de mettre en place des mesures de sécurité compensatoires.

Lorsque l’exécution en tant que root est inévitable, voici une stratégie pour maintenir un niveau de sécurité élevé.

Utiliser des Contextes de Sécurité Restrictifs : Même si le conteneur doit s’exécuter en tant que root, vous pouvez limiter ses capacités en définissant un contexte de sécurité restrictif. Cela inclut la désactivation de privilèges inutiles et la limitation de l’accès au système de fichiers de l’hôte.

...
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: monprojet
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - image: nginx:1.25.3
          name: nginx
          resources:
            limits:
              cpu: "500m"
              memory: "500Mi"
          user: 101
          imagePullPolicy: Always
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true

Mais dans notre cas, cela ne fonctionne pas. Le plus simple réécrire le Dockerfile de l’image nginx en modifiant l’uid du user nginx par exemple :

FROM nginx:latest
RUN usermod -u 10014 nginx && groupmod -g 10014 nginx && \
        mkdir -p /var/cache/nginx/client_temp && \
        chown -R nginx:nginx /usr/share/nginx/html && \
        chown -R nginx:nginx /var/cache/nginx && \
        chown -R nginx:nginx /var/log/nginx && \
        chown -R nginx:nginx /etc/nginx/conf.d && \
        touch /var/run/nginx.pid && \
        chown -R nginx:nginx /var/run/nginx.pid
USER nginx
CMD ["nginx", "-g", "daemon off;"]

J’ai testé et cela fonctionne !

Optimisation de la Résilience avec kube-score

Après avoir abordé la sécurité, un autre aspect fondamental que kube-score aide à améliorer est la résilience des applications déployées sur Kubernetes.

La résilience d’une application fait référence à sa capacité à rester opérationnelle et à récupérer rapidement en cas de défaillances ou de problèmes inattendus. Dans un environnement Kubernetes, cela implique souvent la gestion adéquate des ressources, la mise en place de contrôles de santé et l’assurance que les services sont déployés et mis à jour de manière fiable.

kube-score examine divers aspects de la configuration Kubernetes pour s’assurer que les meilleures pratiques en matière de résilience sont respectées :

Gestion des Ressources : kube-score vérifie si des limites et des demandes de ressources (CPU et mémoire) sont correctement définies pour chaque conteneur. Cela aide à prévenir les cas de saturation des ressources et assure une allocation équitable des ressources dans le cluster.
Probes de Santé (Liveness et Readiness Probes) : kube-score s’assure que les contrôles de santé sont correctement configurés pour chaque conteneur. Les probes permettent à Kubernetes de comprendre quand redémarrer un conteneur qui ne répond plus (liveness probe) et quand un conteneur est prêt à accepter du trafic (readiness probe).
Stratégies de Mise à Jour : kube-score évalue les stratégies de mise à jour des déploiements pour garantir des mises à jour fluides et fiables des applications sans temps d’arrêt.

Reprenons l’exemple et nous voyons que kube-score affiche ce genre de recommendations :

    [CRITICAL] Container Image Pull Policy
        · nginx -> ImagePullPolicy is not set to Always
            It's recommended to always set the ImagePullPolicy to Always, to make sure that the imagePullSecrets are always correct, and to always get the
            image you want.

Dans ce cas, kube-score suggère d’ajouter une ImagePullPolicy pour améliorer la résilience du conteneur. Voici comment vous pourriez mettre en œuvre cette recommandation :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-app
spec:
  template:
    spec:
      containers:
        - image: nginx:1.25.3
          name: nginx
          resources:
            limits:
              cpu: "500m"
              memory: "500Mi"
          imagePullPolicy: Always

En appliquant les recommandations de kube-score relatives à la gestion des ressources, aux probes de santé et aux stratégies de mise à jour, vous pouvez significativement améliorer la résilience de vos applications Kubernetes. Cela garantit que vos applications restent stables, performantes et capables de gérer les défaillances de manière élégante.

Intégration de kube-score dans les Pipelines CI/CD

L’intégration de kube-score dans vos pipelines d’intégration continue (CI) et de déploiement continu (CD) est important pour assurer une analyse et une amélioration constantes de la qualité de vos déploiements Kubernetes. Voici comment procéder à cette intégration pour tirer pleinement parti de kube-score.

Pour un pipeline de déploiement continu, comme avec GitLab CI/CD, ajoutez à votre fichier .gitlab-ci.yml, ajoutez une étape pour exécuter kube-score :

kube-score-check:
  stage: test
  script:
    - kube-score score mon-deploiement.yaml

Cette configuration exécutera kube-score comme partie du stage test de votre pipeline GitLab CI/CD.

Vous pouvez configurer votre pipeline pour échouer si kube-score identifie des problèmes critiques, forçant ainsi une intervention manuelle pour corriger ces problèmes avant que le déploiement ne puisse se poursuivre.

Limitations et Considérations sur l’Utilisation de kube-score

Bien que kube-score soit un outil puissant pour améliorer la qualité des déploiements Kubernetes, il est important de comprendre ses limitations et les considérations à garder à l’esprit lors de son utilisation. Cette compréhension permet d’optimiser l’utilisation de l’outil tout en reconnaissant ses limites.

Limitations de kube-score

Analyse Statique Seulement : kube-score effectue une analyse statique des fichiers de configuration Kubernetes. Il ne peut pas détecter des problèmes qui ne sont visibles qu’à l’exécution ou lors d’interactions dynamiques dans un environnement Kubernetes actif.
Dépendance aux Bonnes Pratiques : Les recommandations de kube-score sont basées sur un ensemble de bonnes pratiques établies. Cela signifie que l’outil pourrait ne pas couvrir tous les scénarios spécifiques ou les cas d’utilisation personnalisés.
Absence d’Analyse de Contexte : kube-score ne prend pas en compte le contexte d’utilisation spécifique de vos ressources Kubernetes. Par exemple, il pourrait recommander des modifications qui ne sont pas pratiques ou souhaitables dans certains environnements ou pour certaines applications.

Considérations lors de l’Utilisation

Complémentarité avec d’Autres Outils : Utilisez kube-score en complément d’autres outils de surveillance, de dépannage et de sécurité pour obtenir une vue complète de la santé de votre infrastructure Kubernetes.
Adaptation aux Besoins Spécifiques : Adaptez les recommandations de kube-score à vos besoins spécifiques. Certaines suggestions peuvent nécessiter une modification pour s’aligner avec les politiques internes ou les contraintes opérationnelles.
Mise en Balance des Recommandations : Évaluez les recommandations de kube-score par rapport à l’effort nécessaire pour les mettre en œuvre et l’impact potentiel sur vos systèmes. Certaines améliorations peuvent offrir des bénéfices marginaux par rapport à l’investissement requis pour les implémenter.
Formation et Conscience : Assurez-vous que votre équipe comprend comment interpréter et agir sur les résultats de kube-score. Une formation adéquate peut aider à maximiser l’efficacité de l’outil.

Conclusion

kube-score est un outil précieux pour améliorer vos déploiements Kubernetes, mais il doit être utilisé en tenant compte de ses limitations et en complément d’autres stratégies et outils de gestion de Kubernetes. Une approche équilibrée et informée garantira que vous tirez le meilleur parti de kube-score tout en maintenant une infrastructure Kubernetes saine et robuste.

Plus d’infos

Pour plus d’informations et pour approfondir votre compréhension de kube-score, consultez les ressources suivantes :

Site officiel : kube-score.com ↗
Documentation : GitHub - kube-score ↗
Projet GitHub : zegl/kube-score ↗