Outils incontournables du DevOps

Bonnes pratiques (policies)

• Trunk-based, PR petites (< 300 lignes), reviews & checks obligatoires.
• Branch protections : no force-push, required status checks, signed commits.
• Conventional Commits + CHANGELOG auto + tags semver.
• CODEOWNERS, .gitattributes (normalisation EOL), .gitignore stricte.
• Scans secrets (pre-commit + pre-receive), BFG pour purge historique.

Repo strategy

• Monorepo (outillage + règles) vs multi-repo (autonomie) — choisir et documenter.
• Templates de repo (CI, licences, sécurité) & scripts bootstrap.

Snippets & templates

# CODEOWNERS (extrait)
infra/**   @platform-team
web/**     @frontend-core
.github/** @secops

# .pre-commit-config.yaml (extrait)
repos:
  - repo: https://github.com/psf/black
    rev: 24.4.2
    hooks: [{id: black}]
  - repo: https://github.com/zricethezav/gitleaks
    rev: v8.18.0
    hooks: [{id: gitleaks}]

# PR template (extrait)
## Objet | Risques | Tests
- ...
Checklist: [ ] tests [ ] docs [ ] breaking change [ ] sécurité validée

Comparatif & KPIs

• KPIs : lead-time PR, % PR sans rework, taux secrets détectés = 0.
• Anti-patterns : branches longues, force-push, binaires commités.

Pipeline de référence

• Trunk-based → build → tests (unit/int/e2e) → SAST/DAST → SBOM → image signée.
• Artefacts immuables, promotion dev→staging→prod, PR GitOps pour manifests.
• Stratégies : rolling, blue-green, canary (progressive delivery, Spinnaker/Argo Rollouts).
• Envs éphémères par PR, cache & parallélisme, timeouts, rate-limit.

KPIs DORA

• Déploiements quotidiens/hebdo, lead-time < 48h, échec < 10%, MTTR < 60m.

Snippets (CI/CD)

# Jenkinsfile (extrait)
pipeline {
  agent any
  options { timestamps(); timeout(time:30, unit:'MINUTES') }
  stages {
    stage('Test'){ steps{ sh 'pytest -q' } }
    stage('Build'){ steps{ sh 'docker build -t app:${GIT_COMMIT} .' } }
    stage('SBOM'){ steps{ sh 'syft . -o json > sbom.json' } }
  }
}

# ArgoCD Application (extrait)
apiVersion: argoproj.io/v1alpha1
kind: Application
spec:
  source: { repoURL:"...", path:"overlays/prod", targetRevision:"main" }
  destination: { server:"https://kubernetes.default.svc", namespace:"app" }
  syncPolicy: { automated:{ prune:true, selfHeal:true }, syncOptions:["CreateNamespace=true"] }

# Spinnaker (pipeline, extrait)
{ "stages":[
  {"type":"bakeManifest","name":"Render Helm"},
  {"type":"deployManifest","name":"Canary"},
  {"type":"manualJudgment","name":"Promote or Rollback"}
]}

Anti-patterns & Guardrails

• CI lente/flake → tests parallèles, pyramide de tests, quarantine des flakies.
• CD manuel opaque → GitOps + approvals + politiques de rollback documentées.
• Secrets en clair/logs → masking, vault, no long-lived keys, SBOM signé.
• Pas d’inventaire d’artefacts → registry (GHCR/Harbor/Nexus) + rétention.

Comparatif bref

Piliers & pratiques

• Instrumentation OpenTelemetry (traces/metrics/logs) + exporters.
• Dashboards Golden Signals, alertes symptomatiques liées aux SLO.
• Rétention multi-niveaux (chaud/froid), budgets coûts observabilité.

Comparatif rapide

Snippets (OTel/Prom/Loki/NRQL)

# OTel Collector (extrait)
receivers: { otlp: { protocols: { http: {}, grpc: {} } } }
exporters: { prometheus: {}, loki: { endpoint: http://loki:3100/loki/api/v1/push } }
service: { pipelines: { traces: { receivers:[otlp], exporters:[loki] } } }

# PromQL: p95 par service
histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service))

# Loki: erreurs structurées
{app="checkout"} |= "ERROR" | json | line_format " "

# NewRelic (NRQL)
SELECT percentile(duration,95) FROM Transaction WHERE appName='checkout' TIMESERIES

SLO & Alerting

• SLO par criticité (or/argent/bronze) + budgets d’erreur mensuels.
• Alertes avec for + grouping cohérent, runbooks reliés à chaque alerte.
• PII masquée (logs JSON), cardinalité contrôlée (labels Loki, Prom).

# PrometheusRule (extrait)
expr: rate(http_requests_errors_total[5m]) / rate(http_requests_total[5m]) > 0.02
for: 10m
labels: {severity:"page"}
annotations: {summary:"Erreur > 2% sur checkout"}

Modèles & pratiques

• Vault : KV v2, Transit, dynamic secrets, OIDC/JWT, audit immuable.
• SOPS : chiffrement dans Git (age/KMS), encrypted_regex, PR review.
• KMS : envelope, rotation, clés par env/service, intégration CSI (K8s).
• Injecter secrets via sidecar/CSI, éviter variables d’env en clair.

Guardrails

• No long-lived keys (OIDC runners → cloud STS).
• Rotation < 90j, scopes min (least privilege), segmentation par namespace.
• Plans break-glass testés, backups de secrets chiffrés uniquement.

Snippets

# SOPS (extrait)
sops:
  kms: ["arn:aws:kms:eu-west-1:123:key/abcd"]
  encrypted_regex: '^(data|stringData)$'

# Vault policy (ex.)
path "secret/data/app/*" { capabilities = ["read","list"] }

# KMS envelope (pseudo)
DEK = KMS.GenerateDataKey()
cipher = AES-GCM(DEK).encrypt(data)
store(cipher, KMS.Encrypt(DEK))

Comparatif & KPIs

• KPIs : incidents secrets = 0, TTR fuite < 15m, % rotation dans le délai > 95%.

Pratiques & livrables

• SSoT : ADR, runbooks, RFC & post-mortems dans Confluence (index structuré).
• Workflows Jira simples (ToDo → In Progress → Review → Done), WIP limité.
• ChatOps : commandes CI/CD, alertes SLO, canaux #prod-incidents standardisés.

Templates

# Post-mortem (squelette)
Résumé | Impact | Timeline | RCA (5 whys)
Actions (owner, due) | Lessons | Prévention

# Front-matter runbook (YAML)
service: checkout-api
owner: sre@team
dashboards: [grafana:123]
slo: {availability: 99.9, latency_p95_ms: 300}

Intégrations ChatOps

• Slash commands → déclencher pipelines / déploiements / affichage SLO.
• Bot incident : création ticket Jira + canal dédié + checklist automatique.
• Webhooks observabilité vers #on-call avec lien runbook.

# Exemples Slack
/deploy app=checkout env=prod strategy=canary
/slo show checkout
/incident new "p95 > 1s"

KPIs & Guardrails

• Temps de tri incident < 10 min, actions post-mortem soldées > 90% à J+30.
• RACI on-call documenté, escalade claire, calendrier publié.
• Pas de décisions clés en DM : tout dans canaux publics référencés.