centraliser les logs kubernetes avec elasticsearch, fluentd et kibana : guide technique complet

Introduction

Dans un cluster Kubernetes, centraliser les logs est essentiel pour diagnostiquer rapidement les incidents, suivre les performances et détecter les anomalies de sécurité. Cette approche “EFK” (Elasticsearch, Fluentd, Kibana) permet de :

• Collecter automatiquement les logs de chaque pod.
• Indexer et stocker les données de façon distribuée.
• Visualiser et rechercher les événements en temps réel.

Ce guide technique détaille le déploiement pas à pas, avec des manifests, des commandes kubectl et des recommandations de performance.

Étape 1 : déployer Elasticsearch

Elasticsearch stocke et indexe les logs. On recommande la version 8.x pour profiter des dernières optimisations (compression RLZ, search throttling).

1. Créer un PersistentVolume et un StatefulSet :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: es-pvc
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 20Gi
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: elasticsearch
spec:
  serviceName: "es-service"
  replicas: 3
  selector:
    matchLabels:
      app: elasticsearch
  template:
    metadata:
      labels:
        app: elasticsearch
    spec:
      containers:
      - name: es
        image: docker.elastic.co/elasticsearch/elasticsearch:8.5.1
        ports:
        - containerPort: 9200
        env:
        - name: discovery.type
          value: "zen"
        volumeMounts:
        - name: es-storage
          mountPath: /usr/share/elasticsearch/data
  volumeClaimTemplates:
  - metadata:
      name: es-storage
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 20Gi

Puis :

kubectl apply -f elasticsearch-statefulset.yaml
kubectl rollout status statefulset/elasticsearch

Après déploiement, vérifiez l’état :

curl -u elastic: http://elasticsearch:9200/_cluster/health?pretty

Étape 2 : installer Fluentd comme DaemonSet

Fluentd collecte les logs des nœuds Linux et des conteneurs Docker, puis les envoie à Elasticsearch.

1. Créer un ConfigMap pour la configuration :

apiVersion: v1
kind: ConfigMap
metadata:
  name: fluentd-config
data:
  fluent.conf: |
    
      @type tail
      path /var/log/containers/*.log
      pos_file /var/log/fluentd-containers.log.pos
      tag kube.*
      format json
    
    
      @type elasticsearch
      host elasticsearch
      port 9200
      logstash_format true
      type_name fluentd
      include_tag_key true
    

2. Déployer le DaemonSet :

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
spec:
  selector:
    matchLabels:
      app: fluentd
  template:
    metadata:
      labels:
        app: fluentd
    spec:
      tolerations:
      - key: node-role.kubernetes.io/master
        operator: Exists
        effect: NoSchedule
      containers:
      - name: fluentd
        image: fluent/fluentd:v1.14.2
        volumeMounts:
        - name: config
          mountPath: /fluentd/etc
        - name: varlog
          mountPath: /var/log
      volumes:
      - name: config
        configMap:
          name: fluentd-config
      - name: varlog
        hostPath:
          path: /var/log

kubectl apply -f fluentd-daemonset.yaml
kubectl get ds fluentd

Étape 3 : déployer Kibana

Kibana offre un dashboard interactif pour explorer les logs.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kibana
spec:
  replicas: 2
  selector:
    matchLabels:
      app: kibana
  template:
    metadata:
      labels:
        app: kibana
    spec:
      containers:
      - name: kibana
        image: docker.elastic.co/kibana/kibana:8.5.1
        ports:
        - containerPort: 5601
        env:
        - name: ELASTICSEARCH_HOSTS
          value: "http://elasticsearch:9200"
---
apiVersion: v1
kind: Service
metadata:
  name: kibana-svc
spec:
  type: ClusterIP
  ports:
  - port: 5601
    targetPort: 5601
  selector:
    app: kibana

Accédez ensuite à http://:5601 et configurez l’index pattern logstash-*.

Bonnes pratiques et optimisation

• Limiter la rétention des logs dans Elasticsearch (par défaut à 7 jours) via la Index Lifecycle Management (ILM) pour maîtriser les coûts.
• Réserver 50 % de la mémoire système à Elasticsearch et ajuster heap.size pour éviter le GC long (max 31 Go).
• Activer la compression best_compression pour réduire l’usage disque de ~30 %.
• Surveiller les métriques clés (indexing_rate, search_latency) via Grafana ou Prometheus.
• Configurer des limites CPU/mémoire sur Fluentd (par exemple cpu: 200m, memory: 300Mi) pour éviter qu’il ne “cannibalise” les pods applicatifs.

Conclusion

En quelques commandes kubectl et manifests YAML, vous obtenez une solution robuste pour collecter, indexer et visualiser tous les logs de votre plateforme Kubernetes. Ce pipeline EFK vous apportera :

• Une vue unifiée sur les incidents et erreurs applicatives.
• Un gain de temps sur le debugging (recherche full text en <100 ms).
• Une base pour la détection d’anomalies (alerting, machine learning).

Besoin d’aide pour déployer ou industrialiser votre solution de logging ? Contactez nos experts pour un audit ou un accompagnement sur mesure.