Polaris : auditer et corriger vos manifests Kubernetes

Vos manifests Kubernetes passent en CI, mais une fois en production, vous découvrez des pods qui tournent en root, sans limites de mémoire, ou avec des images latest. Polaris détecte ces problèmes avant le déploiement et peut même les corriger automatiquement. Ce guide vous apprend à auditer vos YAML en une commande, intégrer Polaris dans votre CI/CD, et créer vos propres règles de conformité.

Ce que vous allez apprendre

• Auditer des manifests YAML ou des charts Helm en 2 minutes
• Faire échouer votre pipeline CI si le score est trop bas ou si des erreurs critiques existent
• Personnaliser les règles avec des custom checks JSON Schema
• Déployer le dashboard et l’admission controller dans un cluster

---

Pourquoi Polaris ?

Imaginez une équipe qui déploie une application e-commerce. Le manifest YAML passe tous les tests unitaires, mais personne ne remarque que :

• Le conteneur tourne en root (risque de compromission totale du nœud)
• Aucune limite mémoire n’est définie (un conteneur peut consommer toute la RAM du nœud)
• L’image utilise le tag latest (impossible de savoir quelle version tourne réellement)
• Les probes de santé sont absentes (Kubernetes ne sait pas si l’app fonctionne)

Ces erreurs passent inaperçues jusqu’à l’incident. Polaris les détecte avant que le manifest n’atteigne le cluster.

Ce que fait Polaris

Polaris analyse vos workloads Kubernetes (Deployments, StatefulSets, DaemonSets, Jobs, CronJobs) et vérifie qu’ils respectent les bonnes pratiques. Il fonctionne de trois façons :

Mode	Ce qu’il fait	Quand l’utiliser
CLI / audit	Analyse des fichiers YAML ou un cluster	CI/CD, vérification ponctuelle
Dashboard	Interface web pour visualiser les problèmes	Triage, visibilité équipe
Admission Controller	Bloque ou alerte sur les workloads non conformes	Enforcement en production

Glissez pour voir

Polaris vs autres outils

Outil	Spécialité	Quand le choisir
Polaris	Best practices workloads + score + remédiation	Hygiène de base, CI/CD simple
kube-score	Best practices workloads	Alternative légère à Polaris
Kyverno	Policy engine complet (admission + mutation)	Policies complexes, multi-cluster
OPA/Gatekeeper	Policy engine (Rego)	Politiques avancées, conformité entreprise
Kubescape	Sécurité (NSA, MITRE, CIS)	Audits de conformité sécurité

Glissez pour voir

En résumé : Polaris est idéal pour commencer avec les bonnes pratiques. Si vous avez besoin de politiques complexes (RBAC, NetworkPolicies, quotas), regardez Kyverno ou Gatekeeper.

---

Quickstart en 5 minutes

Auditer un dossier de manifests

1. Installer Polaris

   curl -fsSL https://github.com/FairwindsOps/polaris/releases/download/10.1.4/polaris_linux_amd64.tar.gz | \
     sudo tar -xzf - -C /usr/local/bin polaris
   
   polaris version
   # Polaris version:10.1.4

2. Lancer un audit

   polaris audit --audit-path ./k8s/ --format pretty

   Sortie typique pour un manifest problématique :

   Polaris audited Path ./k8s/ at 2026-02-02T07:43:15+01:00
       Nodes: 0 | Namespaces: 0 | Controllers: 1
       Final score: 40
   
   Deployment webshop-api in namespace production
       deploymentMissingReplicas            😬 Warning
           Reliability - Only one replica is scheduled
       missingPodDisruptionBudget           😬 Warning
           Reliability - Should have a PodDisruptionBudget
     Container api
       tagNotSpecified                      ❌ Danger
           Reliability - Image tag should be specified
       runAsPrivileged                      ❌ Danger
           Security - Should not be running as privileged
       cpuRequestsMissing                   😬 Warning
           Efficiency - CPU requests should be set

3. Interpréter les résultats

   Icône	Niveau	Signification
   🎉	Success	Check réussi
   😬	Warning	Problème potentiel, à investiguer
   ❌	Danger	Erreur critique, à corriger

   Glissez pour voir

Intégrer en CI/CD (GitLab CI, GitHub Actions)

Faites échouer le pipeline si des erreurs critiques sont détectées :

# Échoue (exit code 3) si au moins un "Danger" est trouvé
polaris audit --audit-path ./k8s/ --set-exit-code-on-danger --format pretty

# Échoue (exit code 4) si le score est inférieur à 80
polaris audit --audit-path ./k8s/ --set-exit-code-below-score 80 --format score

GitLab CI

.gitlab-ci.yml

polaris:
  stage: validate
  image: quay.io/fairwinds/polaris:10.1.4
  script:
    - polaris audit --audit-path ./k8s/ --set-exit-code-on-danger --format pretty
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

GitHub Actions

.github/workflows/polaris.yml

name: Polaris Audit
on: [pull_request]

jobs:
  polaris:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Polaris
        run: |
          curl -fsSL https://github.com/FairwindsOps/polaris/releases/download/10.1.4/polaris_linux_amd64.tar.gz | \
            tar -xzf - -C /usr/local/bin polaris
      - name: Audit manifests
        run: polaris audit --audit-path ./k8s/ --set-exit-code-on-danger --format pretty

Auditer un chart Helm

Polaris peut template un chart Helm et l’auditer :

# Auditer un chart local
polaris audit --helm-chart ./my-chart/ --format pretty

# Avec des values personnalisées
polaris audit --helm-chart ./my-chart/ --helm-values values-prod.yaml --format pretty

---

Comprendre Polaris

Les 3 catégories de checks

Polaris organise ses vérifications en trois catégories :

Catégorie	Ce qu’elle vérifie	Exemples
Security	Risques de sécurité	runAsRoot, privileged, hostNetwork, capabilities
Efficiency	Utilisation des ressources	cpuRequests, memoryLimits
Reliability	Stabilité et résilience	probes, replicas, PDB, imageTag

Glissez pour voir

Les niveaux de sévérité

Chaque check a un niveau de sévérité configurable :

Niveau	Impact sur le score	Usage
ignore	Aucun	Désactiver un check
warning	Réduit légèrement le score	Problème à corriger
danger	Réduit fortement le score	Problème critique

Glissez pour voir

Le score Polaris

Polaris calcule un score de 0 à 100. Chaque check échoué réduit le score selon sa sévérité.

Score	Interprétation
90-100	Excellent, prêt pour la production
70-89	Correct, quelques améliorations possibles
50-69	Problèmes à corriger avant production
< 50	Critique, ne pas déployer

Glissez pour voir

Stratégie progressive

Commencez avec un seuil bas (ex: 60) et augmentez-le progressivement. Cela évite de bloquer toutes les MR dès le premier jour.

---

Installer Polaris

CLI (binaire)

# Linux amd64
curl -fsSL https://github.com/FairwindsOps/polaris/releases/download/10.1.4/polaris_linux_amd64.tar.gz | \
  sudo tar -xzf - -C /usr/local/bin polaris

# macOS (arm64)
curl -fsSL https://github.com/FairwindsOps/polaris/releases/download/10.1.4/polaris_darwin_arm64.tar.gz | \
  sudo tar -xzf - -C /usr/local/bin polaris

# Vérifier
polaris version

Container (CI/CD)

docker run --rm -v $(pwd):/audit quay.io/fairwinds/polaris:10.1.4 \
  polaris audit --audit-path /audit/k8s/ --format pretty

Dashboard et Webhook (Helm)

# Ajouter le repo Fairwinds
helm repo add fairwinds-stable https://charts.fairwinds.com/stable
helm repo update

# Installer dashboard + webhook
helm install polaris fairwinds-stable/polaris \
  --namespace polaris \
  --create-namespace \
  --set webhook.enable=true \
  --set dashboard.enable=true

# Accéder au dashboard
kubectl port-forward -n polaris svc/polaris-dashboard 8080:80
# Ouvrir http://localhost:8080

---

Utiliser Polaris au quotidien

polaris audit — Auditer

# Auditer un fichier ou dossier
polaris audit --audit-path ./deployment.yaml --format pretty

# Auditer un cluster (nécessite kubeconfig)
polaris audit --format pretty

# Auditer un namespace spécifique
polaris audit --namespace production --format pretty

# N'afficher que les échecs
polaris audit --audit-path ./k8s/ --only-show-failed-tests --format pretty

# Filtrer par sévérité (danger uniquement)
polaris audit --audit-path ./k8s/ --severity danger --only-show-failed-tests --format pretty

Formats de sortie :

Format	Usage
pretty	Lisible pour humains (CI logs)
json	Intégration avec d’autres outils
yaml	Même chose en YAML
score	Retourne uniquement le score (0-100)

Glissez pour voir

polaris fix — Corriger automatiquement

Polaris peut corriger automatiquement certains problèmes :

polaris fix --files-path ./deployment.yaml --checks all

Ce que fix peut corriger :

• Ajouter securityContext (runAsNonRoot, readOnlyRootFilesystem, etc.)
• Ajouter des resources (requests/limits) avec des valeurs par défaut
• Ajouter des probes (liveness/readiness) avec des placeholders
• Définir imagePullPolicy: Always
• Ajouter replicas: 3

Relisez toujours les corrections

polaris fix ajoute des valeurs par défaut (ex: memory: 512Mi). Ces valeurs sont des placeholders, pas des recommandations pour votre application. Relisez et ajustez.

Exemple avant/après :

Avant (problématique)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webshop-api
spec:
  replicas: 1
  template:
    spec:
      containers:
      - name: api
        image: mycompany/webshop-api:latest
        securityContext:
          privileged: true

Après (corrigé)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webshop-api
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: api
        image: mycompany/webshop-api:latest
        imagePullPolicy: Always
        securityContext:
          privileged: false
          runAsNonRoot: true
          readOnlyRootFilesystem: true
          allowPrivilegeEscalation: false
          capabilities:
            drop:
              - ALL
        resources:
          limits:
            memory: 512Mi  # TODO: ajuster
            cpu: 100m      # TODO: ajuster
          requests:
            cpu: 100m      # TODO: ajuster
            memory: 512Mi  # TODO: ajuster
        readinessProbe:
          # TODO: configurer
          exec:
            command: [cat, /tmp/healthy]
        livenessProbe:
          # TODO: configurer
          exec:
            command: [cat, /tmp/healthy]

Dashboard — Visualiser

Le dashboard donne une vue d’ensemble du cluster :

• Score global par namespace
• Top des problèmes (les plus fréquents)
• Détail par workload (Deployment, StatefulSet, etc.)
• Historique (si configuré avec Fairwinds Insights)

Utile pour :

• Identifier les namespaces les plus problématiques
• Prioriser les corrections
• Montrer l’évolution à l’équipe

Admission Controller — Bloquer

L’admission controller intercepte les requêtes kubectl apply et peut :

• Bloquer les workloads non conformes (mode reject)
• Alerter sans bloquer (mode warn)

Déployez progressivement

Commencez en mode warn (alertes uniquement) pour voir ce qui serait bloqué. Passez en mode reject une fois les équipes prêtes.

---

Personnaliser les règles

Activer/désactiver des checks

Créez un fichier polaris-config.yaml :

polaris-config.yaml

checks:
  # Désactiver des checks
  cpuLimitsMissing: ignore
  priorityClassNotSet: ignore

  # Changer la sévérité
  tagNotSpecified: danger      # par défaut: danger
  runAsRootAllowed: danger     # par défaut: warning
  memoryLimitsMissing: warning # par défaut: warning

Utilisez-le avec --config :

polaris audit --config polaris-config.yaml --audit-path ./k8s/ --format pretty

Exemptions (ignorer certains workloads)

Vous pouvez exempter des namespaces ou des workloads spécifiques :

polaris-config.yaml

exemptions:
  # Exempter tout kube-system
  - namespace: kube-system
    rules:
      - runAsRootAllowed
      - runAsPrivileged

  # Exempter un workload spécifique
  - namespace: monitoring
    controllerNames:
      - prometheus-server
    rules:
      - hostNetworkSet

Vous pouvez aussi ajouter une annotation directement sur le workload :

metadata:
  annotations:
    polaris.fairwinds.com/exempt: "true"
    # ou exempter un check spécifique
    polaris.fairwinds.com/runAsRootAllowed-exempt: "true"

Custom checks (JSON Schema)

Polaris permet de créer vos propres règles avec JSON Schema. C’est la fonctionnalité la plus puissante pour adapter Polaris à vos besoins.

Exemple : interdire les images de quay.io

polaris-config.yaml

checks:
  imageRegistry: warning

customChecks:
  imageRegistry:
    successMessage: Image comes from allowed registries
    failureMessage: Image should not be from quay.io
    category: Security
    target: Container
    schema:
      '$schema': https://json-schema.org/draft/2019-09/schema
      type: object
      properties:
        image:
          type: string
          not:
            pattern: ^quay.io

Test :

polaris audit --config polaris-config.yaml --audit-path ./deployment-quay.yaml --format pretty

Résultat :

  Container app
    imageRegistry                        😬 Warning
        Security - Image should not be from quay.io

Options disponibles pour les custom checks :

Option	Description
target	Cible : Container, PodSpec, PodTemplate, Controller, ou apps/Deployment
category	Security, Efficiency, ou Reliability
controllers.include	Limiter à certains types (ex: [Deployment, StatefulSet])
containers.exclude	Exclure initContainer ou container
schema	JSON Schema à valider

Glissez pour voir

Exemple avancé : vérifier les limites de ressources

polaris-config.yaml

checks:
  resourceLimits: warning

customChecks:
  resourceLimits:
    successMessage: Resource limits are within range
    failureMessage: Memory should be between 128Mi and 4Gi
    category: Efficiency
    target: Container
    containers:
      exclude:
        - initContainer
    schema:
      '$schema': https://json-schema.org/draft/2019-09/schema
      type: object
      required:
        - resources
      properties:
        resources:
          type: object
          required:
            - limits
          properties:
            limits:
              type: object
              required:
                - memory
              properties:
                memory:
                  type: string
                  resourceMinimum: 128Mi
                  resourceMaximum: 4Gi

resourceMinimum / resourceMaximum

Polaris étend JSON Schema avec resourceMinimum et resourceMaximum pour comparer les chaînes de ressources Kubernetes (100m, 512Mi, 2Gi).

---

Bonnes pratiques production

1. Versionner votre configuration

mon-projet/
├── k8s/
│   ├── deployment.yaml
│   └── service.yaml
├── polaris/
│   ├── config-base.yaml      # Règles communes
│   ├── config-dev.yaml       # Seuils relâchés pour dev
│   └── config-prod.yaml      # Seuils stricts pour prod
└── .gitlab-ci.yml

2. Stratégie progressive

Phase	Score minimum	Sévérité bloquante	Durée
1. Observation	Aucun (rapport seul)	Aucune	2 semaines
2. Warning	50	Danger uniquement	1 mois
3. Strict	70	Warning + Danger	Production
4. Optimal	85	Tout	Long terme

Glissez pour voir

3. Exemptions ciblées, pas globales

# ❌ Mauvais : désactiver globalement
checks:
  runAsRootAllowed: ignore

# ✅ Bon : exempter uniquement ce qui doit l'être
exemptions:
  - namespace: kube-system
    controllerNames:
      - kube-proxy
    rules:
      - runAsRootAllowed

4. Utiliser --only-show-failed-tests en CI

# Moins verbeux, plus lisible dans les logs CI
polaris audit --audit-path ./k8s/ \
  --set-exit-code-on-danger \
  --only-show-failed-tests \
  --format pretty

---

Dépannage

Symptôme	Cause	Solution
Score différent d’un run à l’autre	Configuration différente	Toujours passer --config explicitement
Passe en local mais échoue en CI	Version Polaris différente	Épingler la version dans le CI
Check ne s’applique pas	target mal configuré	Vérifier target: Container vs target: PodSpec
Webhook bloque trop	Mode reject trop strict	Passer en mode warn puis corriger progressivement
Exemption ignorée	Mauvais namespace/controllerName	Vérifier l’orthographe exacte
Custom check ne match pas	JSON Schema incorrect	Tester avec un outil JSON Schema validator

Glissez pour voir

Debugger un custom check

# Voir les checks actifs
polaris audit --config ./config.yaml --audit-path ./deploy.yaml --format json | jq '.Results[].PodResult.ContainerResults[].Results'

---

À retenir

Concept	Ce qu’il faut retenir
polaris audit	Audite YAML, cluster ou Helm chart
—set-exit-code-on-danger	Fait échouer le CI sur erreurs critiques
—set-exit-code-below-score	Fait échouer le CI sous un seuil
polaris fix	Corrige automatiquement (à relire !)
Custom checks	JSON Schema pour vos règles métier
Exemptions	Par namespace, workload ou annotation
Score	0-100, visez > 70 pour la prod

Glissez pour voir

Checklist CI/CD

1. ✅ Installer Polaris (version épinglée)
2. ✅ --audit-path ./k8s/
3. ✅ --set-exit-code-on-danger (minimum)
4. ✅ --only-show-failed-tests (lisibilité)
5. ✅ --config polaris-config.yaml (reproductibilité)

---

Prochaines étapes

Kubescape Audits de conformité NSA, MITRE, CIS

Kube-score Alternative légère à Polaris

Helm : values et personnalisation Configurer vos charts proprement

×

📖 Voir la documentation →