Skip to content
Learni
Voir tous les tutoriels
SRE et Ops

Comment mener des postmortems blameless en 2026

18 minEXPERT
DevOpsSREPostmortems
Read in English

Introduction

Les postmortems blameless constituent un pilier fondamental des pratiques SRE modernes. Contrairement aux analyses traditionnelles axées sur la faute, ils se concentrent exclusivement sur les systèmes, processus et signaux manqués. Cette approche favorise une culture de sécurité psychologique où les équipes partagent librement les détails d'un incident. En 2026, avec des systèmes distribués de plus en plus complexes, maîtriser cette méthodologie devient indispensable pour réduire le MTTR et améliorer la résilience globale. Ce tutoriel vous guide pas à pas dans l'implémentation concrète de postmortems blameless, incluant des templates prêts à l'emploi et des scripts d'automatisation.

Prérequis

  • Connaissance avancée des pratiques SRE et des incidents de production
  • Accès à un outil de ticketing (Jira, Linear ou équivalent)
  • Environnement Node.js ou Python pour les scripts d'automatisation
  • Culture d'équipe ouverte à l'amélioration continue
  • Outil de visioconférence avec enregistrement (optionnel)

Créer le template Markdown

postmortem-template.md
# Postmortem - Incident #{INCIDENT_ID}

**Date** : {DATE}
**Durée** : {DUREE}
**Impact** : {IMPACT_UTILISATEURS}

## Résumé
Description neutre de l'incident sans mention de personnes.

## Chronologie
- 14:02 : Détection via alerte Prometheus
- 14:05 : Investigation débutée

## Causes racines (5 Whys)
1. Pourquoi ?
2. Pourquoi ?

## Actions correctives
- [ ] Action 1 (owner, deadline)

## Signaux manqués
- Monitoring insuffisant sur X

## Leçons apprises

Ce template Markdown standardise la structure des postmortems. Il force une formulation neutre et oriente vers les systèmes plutôt que les individus. Chaque section est conçue pour être remplie collectivement lors de la réunion.

Script Python de génération

generate_postmortem.py
#!/usr/bin/env python3
import sys
from datetime import datetime

def generate_postmortem(incident_id, impact):
    template = open('postmortem-template.md').read()
    content = template.replace('{INCIDENT_ID}', incident_id)
    content = content.replace('{DATE}', datetime.now().isoformat())
    content = content.replace('{IMPACT_UTILISATEURS}', impact)
    with open(f'postmortem-{incident_id}.md', 'w') as f:
        f.write(content)
    print(f'Postmortem {incident_id} généré avec succès.')

if __name__ == '__main__':
    generate_postmortem(sys.argv[1], sys.argv[2])

Ce script Python automatise la création du fichier postmortem à partir du template. Il garantit la cohérence des documents et permet une intégration facile dans un pipeline CI/CD ou un workflow Slack.

Étape 1 : Préparer la réunion

Organisez la réunion dans les 48 heures suivant la résolution de l'incident. Invitez uniquement les personnes ayant participé à la résolution ou à l'investigation. Définissez un facilitateur neutre chargé de maintenir le ton blameless. Utilisez un document partagé en temps réel pour capturer les contributions de tous.

Configuration YAML pour outil

postmortem-config.yaml
postmortem:
  max_duration: 90
  required_sections:
    - resume
    - chronologie
    - 5whys
    - actions
  blameless_rules:
    - no_names
    - focus_on_systems
    - psychological_safety
  integrations:
    slack_channel: "#incidents"
    jira_project: "SRE"

Ce fichier de configuration YAML définit les règles strictes de conduite des postmortems. Il peut être lu par un bot Slack ou un outil interne pour vérifier automatiquement la conformité des documents produits.

Script Bash d'automatisation

run_postmortem.sh
#!/bin/bash
set -e
INCIDENT=$1
python3 generate_postmortem.py $INCIDENT "Production impact"
git add postmortem-$INCIDENT.md
git commit -m "chore: postmortem $INCIDENT (blameless)"
gh issue create --title "Postmortem $INCIDENT" --body-file postmortem-$INCIDENT.md

Ce script Bash orchestre la création, la sauvegarde Git et la création automatique d'un ticket. Il garantit que chaque postmortem est tracé et versionné, favorisant la traçabilité et l'apprentissage organisationnel.

Étape 2 : Rédiger les actions

Chaque action corrective doit comporter un owner unique, une date limite et un critère de validation mesurable. Évitez les actions vagues comme « améliorer le monitoring ». Préférez des items concrets tels que « Ajouter une alerte sur la latence p99 du service X avant le 15 mars ».

Template d'action corrective

action-template.json
{
  "actions": [
    {
      "id": "ACT-001",
      "description": "Ajouter alerte Prometheus latence p99 > 800ms",
      "owner": "sre-team",
      "deadline": "2026-03-15",
      "validation": "Alerte déclenchée en staging et production"
    }
  ]
}

Ce format JSON standardise les actions et facilite leur importation dans des outils de gestion de projet. Chaque champ est obligatoire pour garantir l'exécution effective des mesures correctives.

Bonnes pratiques

  • Toujours commencer la réunion par un rappel explicite des règles blameless
  • Limiter la durée à 90 minutes maximum
  • Publier le postmortem dans les 5 jours suivant l'incident
  • Suivre l'avancement des actions lors des revues hebdomadaires
  • Archiver tous les postmortems dans un dépôt accessible à toute l'entreprise

Erreurs courantes à éviter

  • Utiliser des formulations accusatrices même involontairement
  • Omettre les signaux d'alerte manqués
  • Ne pas assigner de propriétaire aux actions
  • Organiser la réunion trop tard après l'incident
  • Stocker les postmortems dans des espaces privés ou non indexés

Pour aller plus loin

Approfondissez ces pratiques avec notre formation SRE Avancé. Découvrez nos formations Learni pour maîtriser l'ensemble du cycle de vie des incidents et la culture d'ingénierie de fiabilité.