Mozilla SOPS : chiffrer vos secrets en toute simplicité

Vous avez probablement connu ce moment de panique : découvrir une clé API, un mot de passe ou un certificat exposés accidentellement dans un dépôt Git public. C'est un problème universel en DevOps. Les équipes adoptent GitOps pour automatiser leurs déploiements, mais voilà le dilemme : comment stocker les secrets en sécurité directement dans le code source, tout en les gardant versionés et accessibles automatiquement par les outils de déploiement ?

C'est exactement pour cela qu'existe Mozilla SOPS — Secrets OPerationS. Cet outil élégant chiffre vos secrets in-repo sans sacrifier la transparence du contrôle de version. Au lieu de secrets en clair, vous committez des fichiers chiffrés, que vos pipelines déchiffrent automatiquement à la volée.

• Comment fonctionne le chiffrement envelope de SOPS
• Installation et configuration de SOPS avec age (le remplaçant moderne de PGP)
• Chiffrer, déchiffrer, éditer vos premiers secrets
• Intégration GitOps avec FluxCD et ArgoCD
• Comparaison avec Sealed Secrets et External Secrets Operator
• Ressources complémentaires et cas d'usage

Le génie de SOPS réside dans son approche du chiffrement envelope. Au lieu de chiffrer un fichier entier (ce qui rendrait le contrôle de version inutile), SOPS chiffre seulement les valeurs tout en laissant la structure du fichier lisible.

Concrètement, avec un fichier YAML contenant :

database:
  password: 'motdepasse123'
  host: 'db.example.com'

SOPS transforme cela en :

database:
  password: ENC[AES256_GCM,data:a7f9e2c1b...,iv:4d2f1e9a...,tag:8c5d...]
  host: 'db.example.com'

Notez que host reste en clair — seules les valeurs sensibles sont chiffrées, et le contexte reste transparent pour le code source.

Sous le capot, SOPS utilise deux niveaux de chiffrement :

1. Chiffrement des données : AES256-GCM chiffre les secrets
2. Chiffrement des clés : KMS (AWS, GCP, Azure) ou age chiffre la clé AES elle-même

C'est l'enveloppe : la clé est elle-même protégée. Les clés d'accès restent centralisées chez votre Key Management Service, tandis que les fichiers SOPS restent sûrs dans votre Git.

Étape 1 : installer SOPS et age

Sur macOS (ou Linux) :

brew install sops age

Vérifiez les installations :

sops --version
age --version

Étape 2 : générer une clé age

age produit une paire de clés RSA-style, ultra-simple. Générez la vôtre :

age-keygen -o ~/.age/key.txt

Cela crée une clé privée dans ~/.age/key.txt. Le fichier contient aussi la clé publique en commentaire. Gardez cette clé privée secrète — ne la committez jamais.

Étape 3 : créer .sops.yaml

À la racine de votre dépôt, créez un fichier .sops.yaml pour configurer SOPS :

creation_rules:
  - path_regex: ^secrets/.*\.ya?ml$
    age: 'age1...vg5x' # Remplacez par votre clé publique age
  - path_regex: ^\.env\.secret$
    age: 'age1...vg5x'

Extrayez votre clé publique :

grep "public key:" ~/.age/key.txt | awk '{print $NF}'

Cette configuration ordonne à SOPS : « Tous les fichiers YAML dans secrets/ utilisent age pour chiffrer la clé ». Vous pouvez ajouter plusieurs clés pour supporter une équipe entière :

age: |
  age1-alice-public-key
  age1-bob-public-key
  age1-charlie-public-key

Créer un secret

Créez un fichier secrets/db-creds.yaml :

database:
  password: 'dev-password-123'
  username: 'dbuser'

Chiffrez-le :

sops --encrypt secrets/db-creds.yaml > secrets/db-creds.enc.yaml

Regardez le résultat :

database:
  password: ENC[AES256_GCM,data:uGQ2MzlmZjI0N2E0NDY...,iv:d8e2c4f1...,tag:9c7b...]
  username: ENC[AES256_GCM,data:nZjQ4NzEwMGY0ZjE1...,iv:2d1c9b5a...,tag:a3f2...]
sops:
  kms: []
  gcp_kms: []
  azure_kv: []
  hc_vault: []
  age:
    - recipient: age1...vg5x
      enc: |
        -----BEGIN AGE ENCRYPTED FILE-----
        AgeBSDvB9pLxjD... # La clé AES chiffrée ici
        -----END AGE ENCRYPTED FILE-----
  lastmodified: '2026-02-05T10:30:00Z'
  mac: ENC[AES256_GCM,data:d8f4c2a9...]
  pgp: []
  encrypted_regex: ^(password|token|secret|key|private).*
  version: 3.7.0

Déchiffrer sur place

Pour voir la valeur en clair (sans modifier) :

sops --decrypt secrets/db-creds.enc.yaml

Affiche le contenu déchiffré une seule fois, pas de modification.

Éditer en sécurité

Pour éditer et rechiffrer automatiquement :

sops --edit secrets/db-creds.enc.yaml

SOPS ouvre un éditeur (nano, vim, VSCode) montrant les vraies valeurs, vous pouvez les modifier, puis ferme l'éditeur et rechiffre tout automatiquement.

Avec JSON

SOPS supporte JSON, ENV, INI et format binaire aussi :

{
	"api": {
		"key": "sk-secret-1234",
		"endpoint": "https://api.example.com"
	}
}

Chiffrement identique : sops --encrypt secrets/api.json.

FluxCD avec decryption provider

Si vous utilisez FluxCD v2, intégrez SOPS avec le decryption provider :

flux bootstrap github \
  --owner=myorg \
  --repo=fleet-config \
  --path=clusters/prod \
  --personal

Créez une Kustomization qui déchiffre automatiquement :

apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: secrets
  namespace: flux-system
spec:
  interval: 10m
  sourceRef:
    kind: GitRepository
    name: fleet-config
  path: ./secrets
  decryption:
    provider: sops
    secretRef:
      name: sops-age
  prune: true
  wait: true

Créez un secret Kubernetes avec la clé age privée :

kubectl create secret generic sops-age \
  --from-file=keys.txt=$HOME/.age/key.txt \
  -n flux-system

FluxCD déchiffre automatiquement tout YAML/JSON chiffré avant d'appliquer.

ArgoCD avec KSOPS ou argocd-vault-plugin

Pour ArgoCD, utilisez l'extension argocd-vault-plugin (AVP) ou KSOPS (Kustomize SOPS) :

Installez KSOPS dans votre cluster :

helm install ksops argo/ksops -n argocd

Modifiez votre ArgoApplication :

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
spec:
  source:
    repoURL: https://github.com/myorg/fleet-config
    path: apps/my-app
    plugin:
      name: kustomize-sops
  destination:
    server: https://kubernetes.default.svc
    namespace: default

ArgoCD détecte KSOPS et déchiffre les secrets avant le déploiement.

Trois approches populaires pour les secrets Kubernetes en GitOps. Voici les différences clés :

Chez SHPV : nous recommandons SOPS + age pour les équipes DevOps modernes qui déploient via FluxCD ou ArgoCD, car c'est l'équilibre parfait entre sécurité, transparence et portabilité.

Envie d'approfondir la gestion des secrets ? Consultez nos guides complémentaires :

• Déployer un Vault HashiCorp pour la centralisation des secrets
• Kubernetes et External Secrets Operator : gérer les secrets à l'échelle
• GitOps avec FluxCD : orchestration sécurisée de vos déploiements

• Mozilla SOPS : https://github.com/getsops/sops
• age : https://github.com/FiloSottile/age
• FluxCD Kustomization Decryption : https://fluxcd.io/flux/components/kustomize/kustomization/#decryption
• ArgoCD + KSOPS : https://github.com/viaduct-ai/kustomize-sops
• Sealed Secrets : https://github.com/bitnami-labs/sealed-secrets
• External Secrets Operator : https://external-secrets.io/

Mozilla SOPS transforme la gestion des secrets en DevOps. Finies les données sensibles en clair dans Git — avec SOPS, vous committez du texte chiffré que seuls vos systèmes autorisés peuvent déchiffrer. L'approche par envelope encryption maintient la structure lisible (utile pour le code review), tandis que age simplifie radicalement la gestion des clés par rapport à PGP.

Que vous déployez avec FluxCD, ArgoCD, ou des scripts perso, SOPS s'intègre seamlessly. Combiné à une bonne politique de gestion des clés (Vault, KMS, rotations régulières), c'est une fondation solide pour l'infrastructure moderne.

Vos secrets. Chiffrés. Versionés. Prêts pour la production. 🔐