Guide complet : installer et configurer Prometheus sur Kubernetes

Vous gérez un cluster Kubernetes en production et vous avez besoin d'une observabilité robuste ? Ce guide complet vous accompagne pas à pas pour installer et configurer Prometheus sur Kubernetes en 2026. Selon le Grafana Labs 2025 Observability Survey, 67% des organisations utilisent Prometheus en production pour leurs clusters Kubernetes.

TL;DR : Ce guide vous montre comment déployer Prometheus via Helm, configurer le scraping des métriques, créer vos premières alertes et vérifier votre installation. Temps estimé : 45 minutes.

Pour maîtriser ces compétences en profondeur, découvrez la formation LFS458 Administration Kubernetes.

Qu'est-ce que Prometheus et pourquoi l'utiliser sur Kubernetes ?

Prometheus est un système de monitoring et d'alerting open-source conçu pour les environnements cloud-native. Développé initialement par SoundCloud, il fait partie de la Cloud Native Computing Foundation depuis 2016.

Prometheus collecte des métriques en mode pull via HTTP. Vous configurez des endpoints que Prometheus interroge à intervalles réguliers. Cette approche simplifie votre architecture réseau.

À retenir : Prometheus stocke les métriques sous forme de séries temporelles identifiées par un nom et des labels clé-valeur.

Pourquoi Prometheus est-il idéal pour Kubernetes ?

Kubernetes expose nativement des métriques au format Prometheus. Vos composants (kubelet, kube-apiserver, etcd) fournissent déjà des endpoints /metrics. Vous n'avez qu'à les scraper.

Composant	Port par défaut	Métriques clés
kubelet	10250	Ressources pods, conteneurs
kube-apiserver	6443	Latence requêtes, erreurs
etcd	2379	Santé cluster, latence
kube-scheduler	10259	Pods en attente

Comme l'explique Björn Rabenstein, co-créateur de Prometheus : « Prometheus a été conçu dès le départ pour les environnements dynamiques où les instances apparaissent et disparaissent constamment » (PromCon 2023).

Prérequis avant l'installation

Avant de commencer votre installation, vérifiez que vous disposez des éléments suivants. Cette étape vous évitera des problèmes en cours de déploiement.

Prérequis techniques

Votre cluster doit répondre à ces critères minimaux :

Kubernetes 1.28+ (version recommandée en 2026)
kubectl configuré et fonctionnel
Helm 3.14+ installé sur votre poste
Stockage persistant : au moins 50 Gi disponibles
RBAC activé sur votre cluster

Vérifiez votre version de Kubernetes :

kubectl version --short
# Résultat attendu : Client Version: v1.29.x / Server Version: v1.29.x

Prérequis en compétences

Vous devez maîtriser les concepts fondamentaux de Kubernetes. Consultez notre guide Bonnes pratiques conteneurisation et Docker si vous débutez.

Pour les ingénieurs infrastructure Kubernetes préparant le CKA, cette installation fait partie des compétences évaluées. La formation LFS458 couvre ce sujet en détail.

À retenir : Prévoyez 2 CPU et 4 Gi de RAM minimum pour Prometheus en environnement de test.

Étape 1 : Préparer votre namespace et les permissions RBAC

Vous allez créer un namespace dédié au monitoring. Cette isolation facilite la gestion des droits et la maintenance.

Créer le namespace monitoring

Exécutez cette commande pour créer votre namespace :

kubectl create namespace monitoring
# Résultat : namespace/monitoring created

Vérifiez la création :

kubectl get namespaces | grep monitoring
# Résultat : monitoring   Active   5s

Configurer le ServiceAccount et les ClusterRoles

Prometheus nécessite des permissions pour découvrir et scraper les pods. Créez ce fichier prometheus-rbac.yaml :

apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus
  namespace: monitoring
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: prometheus
rules:
  - apiGroups: [""]
    resources: ["nodes", "pods", "services", "endpoints"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get"]
  - nonResourceURLs: ["/metrics"]
    verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
  - kind: ServiceAccount
    name: prometheus
    namespace: monitoring

Appliquez cette configuration :

kubectl apply -f prometheus-rbac.yaml
# Résultat : serviceaccount/prometheus created
# clusterrole.rbac.authorization.k8s.io/prometheus created
# clusterrolebinding.rbac.authorization.k8s.io/prometheus created

Étape 2 : Installer Prometheus avec Helm

Helm simplifie considérablement votre installation. Vous bénéficiez de configurations optimisées et de mises à jour facilitées.

Ajouter le repository Helm

Ajoutez le repository prometheus-community à votre configuration Helm :

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
# Résultat : "prometheus-community" has been added to your repositories
# Update Complete. Happy Helming!

Créer votre fichier values.yaml personnalisé

Créez un fichier prometheus-values.yaml adapté à votre environnement :

# prometheus-values.yaml - Configuration 2026
prometheus:
  prometheusSpec:
    retention: 15d
    retentionSize: "45GB"
    resources:
      requests:
        memory: "2Gi"
        cpu: "500m"
      limits:
        memory: "4Gi"
        cpu: "1000m"
    storageSpec:
      volumeClaimTemplate:
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 50Gi
    serviceMonitorSelectorNilUsesHelmValues: false
    podMonitorSelectorNilUsesHelmValues: false

alertmanager:
  enabled: true
  alertmanagerSpec:
    storage:
      volumeClaimTemplate:
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 10Gi

grafana:
  enabled: true
  adminPassword: "votre-mot-de-passe-securise"

Cette configuration vous permet de personnaliser la rétention des données, les ressources allouées et le stockage persistant.

Lancer l'installation

Déployez la stack complète avec cette commande :

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --values prometheus-values.yaml \
  --version 58.0.0

L'installation prend 2 à 5 minutes. Surveillez l'avancement :

kubectl get pods -n monitoring -w

Résultat attendu après déploiement :

NAME                                                     READY   STATUS    RESTARTS   AGE
alertmanager-prometheus-kube-prometheus-alertmanager-0   2/2     Running   0          2m
prometheus-grafana-7c9bc466d5-x2p4q                      3/3     Running   0          2m
prometheus-kube-prometheus-operator-5c4b9c8f55-kx8nj     1/1     Running   0          2m
prometheus-prometheus-kube-prometheus-prometheus-0       2/2     Running   0          2m

À retenir : La version 58.0.0 du chart kube-prometheus-stack intègre Prometheus 2.51, Grafana 10.4 et Alertmanager 0.27.

Pour approfondir le déploiement en production, consultez notre guide Déployer la stack kube-prometheus complète en environnement de production.

Étape 3 : Configurer le scraping des métriques

Votre Prometheus est installé. Maintenant, configurez-le pour collecter les métriques de vos applications.

Comprendre les ServiceMonitors

Un ServiceMonitor est une ressource custom (CRD) qui définit comment Prometheus découvre et scrape vos services. Vous évitez ainsi de modifier la configuration Prometheus manuellement.

Créez ce fichier app-servicemonitor.yaml pour monitorer votre application :

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: my-app-monitor
  namespace: monitoring
  labels:
    release: prometheus
spec:
  selector:
    matchLabels:
      app: my-app
  namespaceSelector:
    matchNames:
      - default
      - production
  endpoints:
    - port: metrics
      interval: 30s
      path: /metrics
      scrapeTimeout: 10s

Appliquez cette configuration :

kubectl apply -f app-servicemonitor.yaml
# Résultat : servicemonitor.monitoring.coreos.com/my-app-monitor created

Vérifier les targets découverts

Accédez à l'interface Prometheus pour vérifier vos targets :

kubectl port-forward -n monitoring svc/prometheus-kube-prometheus-prometheus 9090:9090

Ouvrez http://localhost:9090/targets dans votre navigateur. Vous devez voir vos endpoints avec le statut "UP".

Configurer les annotations pour l'auto-discovery

Vous pouvez aussi utiliser les annotations Kubernetes. Ajoutez ces annotations à vos pods :

metadata:
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "8080"
    prometheus.io/path: "/metrics"

Cette méthode convient pour les déploiements simples. Pour les environnements complexes, préférez les ServiceMonitors.

Étape 4 : Créer vos premières règles d'alerting

Le monitoring sans alerting est incomplet. Configurez des alertes pour être notifié des problèmes.

Créer une PrometheusRule

Créez le fichier alerting-rules.yaml :

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: kubernetes-alerts
  namespace: monitoring
  labels:
    release: prometheus
spec:
  groups:
    - name: kubernetes.rules
      rules:
        - alert: PodCrashLooping
          expr: rate(kube_pod_container_status_restarts_total[15m]) > 0
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "Pod {{ $labels.pod }} redémarre fréquemment"
            description: "Le pod {{ $labels.pod }} dans {{ $labels.namespace }} a redémarré {{ $value }} fois."
        
        - alert: HighMemoryUsage
          expr: (container_memory_usage_bytes / container_spec_memory_limit_bytes) > 0.9
          for: 5m
          labels:
            severity: critical
          annotations:
            summary: "Utilisation mémoire critique"
            description: "Le conteneur {{ $labels.container }} utilise plus de 90% de sa limite mémoire."

Appliquez ces règles :

kubectl apply -f alerting-rules.yaml
# Résultat : prometheusrule.monitoring.coreos.com/kubernetes-alerts created

Vérifiez que vos règles sont chargées :

kubectl get prometheusrules -n monitoring
# Résultat : NAME                 AGE
#            kubernetes-alerts    10s

Selon le rapport Dynatrace 2024 sur l'observabilité, les équipes avec des alertes bien configurées réduisent leur MTTR de 43%.

Étape 5 : Configurer Alertmanager pour les notifications

Alertmanager gère le routage de vos alertes. Configurez-le pour recevoir des notifications par email, Slack ou PagerDuty.

Créer un Secret pour la configuration Alertmanager

Créez le fichier alertmanager-config.yaml :

apiVersion: v1
kind: Secret
metadata:
  name: alertmanager-prometheus-kube-prometheus-alertmanager
  namespace: monitoring
type: Opaque
stringData:
  alertmanager.yaml: |
    global:
      resolve_timeout: 5m
      slack_api_url: 'https://hooks.slack.com/services/VOTRE/WEBHOOK/URL'
    
    route:
      group_by: ['alertname', 'severity']
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 4h
      receiver: 'slack-notifications'
      routes:
        - match:
            severity: critical
          receiver: 'slack-critical'
    
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - channel: '#monitoring'
            send_resolved: true
      - name: 'slack-critical'
        slack_configs:
          - channel: '#alerts-critical'
            send_resolved: true

Appliquez cette configuration :

kubectl apply -f alertmanager-config.yaml
# Résultat : secret/alertmanager-prometheus-kube-prometheus-alertmanager configured

Redémarrez Alertmanager pour prendre en compte la nouvelle configuration :

kubectl rollout restart statefulset alertmanager-prometheus-kube-prometheus-alertmanager -n monitoring

Pour créer des dashboards de visualisation, consultez notre guide Créer des dashboards Grafana performants pour le monitoring Kubernetes.

Étape 6 : Vérifier votre installation

Votre stack est déployée. Vérifiez que tout fonctionne correctement avant de passer en production.

Tester l'accès aux interfaces

Créez des port-forwards pour accéder aux interfaces :

# Prometheus
kubectl port-forward -n monitoring svc/prometheus-kube-prometheus-prometheus 9090:9090 &

# Grafana
kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80 &

# Alertmanager
kubectl port-forward -n monitoring svc/prometheus-kube-prometheus-alertmanager 9093:9093 &

Exécuter une requête PromQL de test

Testez votre installation avec cette requête dans l'interface Prometheus :

up{job="kubelet"}

Vous devez obtenir une valeur 1 pour chaque kubelet de votre cluster.

Vérifier les métriques des composants Kubernetes

Exécutez ces requêtes pour valider la collecte :

# Nombre de pods par namespace
count by (namespace) (kube_pod_info)

# Utilisation CPU des nodes
node_cpu_seconds_total{mode="idle"}

# Métriques API server
apiserver_request_total

À retenir : Si une métrique manque, vérifiez d'abord les targets dans Prometheus, puis les logs du composant concerné.

Dépannage des problèmes courants

Vous rencontrez des difficultés ? Voici les solutions aux problèmes fréquents.

Les pods Prometheus ne démarrent pas

Vérifiez les événements du pod :

kubectl describe pod prometheus-prometheus-kube-prometheus-prometheus-0 -n monitoring

Causes fréquentes :

PVC non créé : vérifiez votre StorageClass
Ressources insuffisantes : augmentez les requests/limits
RBAC incorrect : vérifiez les ClusterRoleBindings

Les targets apparaissent comme "DOWN"

Vérifiez la connectivité réseau :

kubectl exec -n monitoring prometheus-prometheus-kube-prometheus-prometheus-0 -- \
  wget -qO- http://kubernetes.default.svc:443/metrics --no-check-certificate

Consultez notre hub Monitoring et dépannage Kubernetes pour des guides de dépannage approfondis.

Les alertes ne sont pas envoyées

Vérifiez la configuration Alertmanager :

kubectl logs -n monitoring alertmanager-prometheus-kube-prometheus-alertmanager-0

Testez manuellement avec :

curl -X POST http://localhost:9093/api/v1/alerts \
  -H "Content-Type: application/json" \
  -d '[{"labels":{"alertname":"Test"}}]'

Bonnes pratiques pour la production

Pour un déploiement production robuste, appliquez ces recommandations issues de l'expérience terrain.

Dimensionnement et rétention

Environnement	Rétention	Stockage	RAM
Dev/Test	7 jours	20 Gi	2 Gi
Staging	15 jours	50 Gi	4 Gi
Production	30 jours	200 Gi	8 Gi

Haute disponibilité

Pour les environnements critiques, déployez Prometheus en mode HA :

prometheus:
  prometheusSpec:
    replicas: 2
    replicaExternalLabelName: "__replica__"

Les ingénieurs opérations Cloud Kubernetes préparant la certification CKA doivent maîtriser ces configurations. La formation LFS458 couvre ces aspects avancés.

Conclusion et prochaines étapes

Vous avez maintenant un stack Prometheus fonctionnel sur votre cluster Kubernetes. Ce guide complet vous a accompagné de l'installation à la configuration des alertes.

Récapitulatif des étapes

Préparation du namespace et RBAC
Installation via Helm
Configuration du scraping
Création des règles d'alerting
Configuration des notifications
Vérification et tests

Explorez notre carte thématique Formation Kubernetes pour découvrir tous les sujets connexes. Pour une vue d'ensemble, consultez le Guide complet Formation Kubernetes.

À retenir : Un monitoring efficace combine métriques, logs et traces. Prometheus est la fondation sur laquelle vous construisez votre observabilité complète.

Passez à l'action : formez-vous avec SFEIR Institute

Vous souhaitez approfondir vos compétences en monitoring Kubernetes ? SFEIR Institute propose des formations certifiantes adaptées à votre niveau.

Formations recommandées :

LFS458 Administration Kubernetes : 4 jours pour maîtriser l'administration de clusters, incluant le monitoring et l'observabilité. Prépare à la certification CKA.

LFD459 Kubernetes pour les développeurs : 3 jours pour intégrer les bonnes pratiques d'observabilité dans vos applications cloud-native. Prépare au CKAD.

Kubernetes les fondamentaux : 1 journée pour découvrir les concepts essentiels, incluant une introduction au monitoring.

Contactez nos conseillers pour construire votre parcours de formation personnalisé et explorer les possibilités de financement OPCO.

Points clés

Qu'est-ce que Prometheus et pourquoi l'utiliser sur Kubernetes ?

Pourquoi Prometheus est-il idéal pour Kubernetes ?

Prérequis avant l'installation

Prérequis techniques

Prérequis en compétences

Étape 1 : Préparer votre namespace et les permissions RBAC

Créer le namespace monitoring

Configurer le ServiceAccount et les ClusterRoles

Étape 2 : Installer Prometheus avec Helm

Ajouter le repository Helm

Créer votre fichier values.yaml personnalisé

Lancer l'installation

Étape 3 : Configurer le scraping des métriques

Comprendre les ServiceMonitors

Vérifier les targets découverts

Configurer les annotations pour l'auto-discovery

Étape 4 : Créer vos premières règles d'alerting

Créer une PrometheusRule

Étape 5 : Configurer Alertmanager pour les notifications

Créer un Secret pour la configuration Alertmanager

Étape 6 : Vérifier votre installation

Tester l'accès aux interfaces

Exécuter une requête PromQL de test

Vérifier les métriques des composants Kubernetes

Dépannage des problèmes courants

Les pods Prometheus ne démarrent pas

Les targets apparaissent comme "DOWN"

Les alertes ne sont pas envoyées

Bonnes pratiques pour la production

Dimensionnement et rétention

Haute disponibilité

Conclusion et prochaines étapes

Récapitulatif des étapes

Passez à l'action : formez-vous avec SFEIR Institute