Aller au contenu
DevSecOps Logo DevSecOps
Docs
Blog
Blog

Optimisez vos configurations Kubernetes avec Polaris

Mise à jour :

logo polaris

Gérer un cluster Kubernetes efficacement, c’est s’assurer que chaque ressource est correctement configurée pour garantir performance, sécurité et stabilité. Pourtant, entre les erreurs de configuration, les oublis de bonnes pratiques et les failles potentielles, il est facile de laisser passer des imperfections.

Présentation de Polaris

Polaris est un outil open source développé par Fairwinds, conçu pour analyser et améliorer la configuration des workloads Kubernetes. Son objectif est de garantir que les bonnes pratiques sont respectées, en identifiant et en corrigeant les erreurs de configuration qui pourraient impacter la sécurité, la performance et la stabilité d’un cluster.

Pourquoi utiliser Polaris ?

Dans un environnement Kubernetes, il est facile d’omettre des réglages essentiels :

  • Des conteneurs fonctionnant en mode privilégié
  • L’absence de limites CPU/mémoire
  • Des images non signées ou issues de registres publics
  • Des probes de santé mal configurées (liveness/readiness)

Ces petites erreurs peuvent avoir des conséquences majeures sur la sécurité et la fiabilité des applications déployées. Polaris intervient pour détecter ces problèmes et proposer des correctifs adaptés.

Fonctionnalités principales

Polaris offre plusieurs moyens d’évaluer et d’améliorer les configurations Kubernetes :

  • Audit des workloads : analyse statique des fichiers YAML de déploiement avant leur application
  • Tableau de bord interactif : permet de visualiser les problèmes de configuration sur un cluster actif
  • Admission Controller : rejette ou modifie les workloads non conformes en temps réel
  • Intégration CI/CD : vérifie les fichiers Kubernetes dans un pipeline DevOps

En combinant ces approches, Polaris devient un allié puissant pour toute organisation souhaitant appliquer les meilleures pratiques Kubernetes sans effort manuel constant.

Installation de Polaris

Avant de pouvoir utiliser Polaris pour analyser et corriger les configurations Kubernetes, il faut l’installer. Il existe plusieurs méthodes en fonction de votre usage : via Helm, en binaire local, ou avec un conteneur Docker.

Installation avec Helm

L’installation via Helm est la méthode la plus courante pour déployer Polaris dans un cluster Kubernetes. Voici les étapes :

  1. Ajouter le dépôt Helm de Fairwinds :

    Terminal window
    helm repo add fairwinds-stable https://charts.fairwinds.com/stable
    helm repo update

  2. Installer Polaris dans un namespace dédié :

    Terminal window
    helm install polaris fairwinds-stable/polaris --namespace polaris --create-namespace

  3. Vérifier l’installation :

    Terminal window
    kubectl get pods -n polaris

Avec cette installation, Polaris Dashboard est accessible en interne dans le cluster. Pour y accéder en local, utilisez kubectl port-forward :

Terminal window
kubectl port-forward -n polaris svc/polaris-dashboard 8080:80

Ensuite, ouvrez un navigateur et accédez à http://localhost:8080.

2. Installation en binaire local

Si vous souhaitez exécuter Polaris en local pour analyser des fichiers YAML avant leur application, vous pouvez utiliser asdf ou brew.

Avec asdf :

Terminal window
asdf plugin add polaris
asdf install polaris latest
asdf set --hom polaris latest

Avec brew :

Terminal window
brew install fairwinds-stable/polaris

Utilisation du Dashboard Polaris

Une fois Polaris installé sur le cluster avec Helm, j’utilise kubectl port-forward pour l’ouvrir localement :

Terminal window
kubectl port-forward -n polaris svc/polaris-dashboard 8080:80

Puis, on accède au Dashboard via votre navigateur à cette url : url ↗

Dashboard Polaris

2. Comprendre l’interface

Une fois chargé, le Dashboard affiche :

  • Un score global de conformité : une note basée sur les erreurs et avertissements détectés.
  • Une liste des workloads Kubernetes avec des indicateurs de validation.
  • Des recommandations détaillées pour chaque ressource.

Chaque workload est classé avec un code couleur :

  • Bleu : conforme aux bonnes pratiques.
  • Orange : avertissement sur des points à améliorer.
  • Rouge : erreurs critiques à corriger.

3. Analyser et corriger les erreurs

On peut cliquer sur chaque workload pour voir les détails des problèmes détectés. Pour chaque erreur, Polaris fournit :

  • Une explication claire du problème.
  • Une suggestion de correction (ajouter des limites CPU/mémoire, configurer un liveness probe, etc.).
  • Un lien vers la documentation pour approfondir.

En utilisant ces recommandations, on peut modifier ses fichiers YAML ou mettre à jour les configurations de ses workloads existants.

Utilisation de Polaris en ligne de commande (CLI)

Une fois Polaris installé en binaire local, on peut l’utiliser pour analyser des fichiers de configuration Kubernetes avant leur déploiement. Cela permet de s’assurer que les workloads respectent les bonnes pratiques et d’éviter des erreurs dès la phase de développement.

1. Vérifier l’installation

Pour m’assurer que Polaris est bien installé, j’exécute la commande suivante :

Terminal window
polaris --help

Si l’installation est correcte, j’obtiens une liste des options disponibles.

2. Auditer des fichiers YAML locaux

Polaris permet d’analyser un ou plusieurs fichiers YAML avant leur application sur un cluster. Pour auditer une configuration locale, j’utilise :

Terminal window
polaris audit --audit-path ./mon-dossier-k8s/

Cette commande affiche un rapport d’audit, indiquant les erreurs et recommandations :

{
  "PolarisOutputVersion": "1.0",
  "AuditTime": "2025-03-04T15:48:44Z",
  "SourceType": "Path",
  "SourceName": "./Projets/kubernetes-training/vos-manifests/",
  "DisplayName": "./Projets/kubernetes-training/vos-manifests/",
  "ClusterInfo": {
    "Version": "unknown",
    "Nodes": 0,
    "Pods": 0,
    "Namespaces": 0,
    "Controllers": 0
  },
  "Results": [
    {
      "Name": "monsecret",
      "Namespace": "",
      "Kind": "Secret",
      "Results": {},
      "PodResult": null,
      "CreatedTime": "0001-01-01T00:00:00Z"
    },
    {
      "Name": "monsecret",
      "Namespace": "",
      "Kind": "Secret",
      "Results": {},
      "PodResult": null,
      "CreatedTime": "0001-01-01T00:00:00Z"
    },
    {
      "Name": "monsecret",
      "Namespace": "dev",
      "Kind": "SealedSecret",
      "Results": {},
      "PodResult": null,
      "CreatedTime": "0001-01-01T00:00:00Z"
    },
    {
      "Name": "nginx-clusterip-service",
      "Namespace": "",
      "Kind": "Service",
      "Results": {},
      "PodResult": null,
      "CreatedTime": "0001-01-01T00:00:00Z"
    },
    {
      "Name": "nginx-nodeport-service",
      "Namespace": "",
      "Kind": "Service",
      "Results": {},
      "PodResult": null,
      "CreatedTime": "0001-01-01T00:00:00Z"
    }
  ],
  "Score": 100
}

Polaris classe les erreurs en INFO, WARNING et ERROR, selon leur impact.

3. Définir un seuil d’échec

Si j’intègre Polaris dans un pipeline CI/CD, on peut forcer l’échec du pipeline en cas d’erreurs critiques :

Terminal window
polaris audit --audit-path ./manifests/ --set-exit-code-on-danger

Si des erreurs ERROR sont détectées, la commande renvoie un code de sortie non nul (exit 1), ce qui stoppe l’exécution du pipeline.

4. Personnaliser les règles d’audit

Polaris applique par défaut un ensemble strict de règles. Si certaines ne sont pas adaptées à mon projet, on peut les personnaliser via un fichier de configuration YAML.

Exemple d’un fichier polaris-config.yaml :

checks:
  memoryRequestsMissing: warning
  cpuRequestsMissing: error
  runAsRootAllowed: error
  livenessProbeMissing: warning

Puis, on l’utilise avec :

Terminal window
polaris audit --audit-path ./manifests/ --config polaris-config.yaml

Cela permet d’ajuster les niveaux de sévérité et d’ignorer certaines règles si nécessaire.

Conclusion

Polaris est un outil essentiel pour garantir la conformité et la bonne configuration des workloads Kubernetes. Grâce à ses différents modes d’utilisation – audit en ligne de commande, Dashboard interactif, Admission Controller et intégration CI/CD – il permet de détecter et corriger les erreurs avant qu’elles n’impactent la production.

Plus d’infos