SOPS : chiffrer vos secrets dans Git

Vous devez stocker des credentials dans votre dépôt Git, mais les commiter en clair est impensable ? SOPS résout ce problème en chiffrant uniquement les valeurs de vos fichiers YAML, JSON ou ENV, tout en gardant les clés lisibles. Résultat : vos secrets sont protégés, mais vous pouvez toujours faire des diffs et des reviews sur la structure du fichier.

Contrairement à Ansible Vault qui chiffre le fichier entier (rendant les diffs impossibles), ou à HashiCorp Vault qui nécessite une infrastructure dédiée, SOPS offre un compromis pragmatique : chiffrement fort + workflow Git natif.

Ce que vous allez apprendre

• Installation : installer SOPS et age sur Linux, macOS et Windows
• Chiffrement : chiffrer des fichiers YAML/JSON avec age ou KMS
• Multi-clés : configurer plusieurs clés pour une équipe
• Intégrations : Ansible, Kubernetes, CI/CD

Qu’est-ce que SOPS ?

SOPS (Secrets OPerationS) est un éditeur de fichiers chiffrés créé par Mozilla (maintenant maintenu par la communauté sous getsops/sops). Il supporte les formats YAML, JSON, ENV, INI et binaire.

Pourquoi SOPS plutôt qu’autre chose ?

Critère	SOPS + age	Ansible Vault	HashiCorp Vault
Stockage	Fichiers Git	Fichiers Git	Service centralisé
Diffs lisibles	✅ Oui (clés visibles)	❌ Non (blob chiffré)	N/A
Infrastructure	Aucune	Aucune	Serveur + HA
Multi-clés	✅ Natif	❌ 1 mot de passe	✅ Policies avancées
Cloud KMS	✅ AWS/GCP/Azure	❌	✅ Transit

Glissez pour voir

Comment SOPS chiffre les fichiers ?

SOPS ne chiffre que les valeurs, pas les clés. Voici un exemple :

Fichier original

database:
  host: db.example.com
  username: admin
  password: super-secret-123

Fichier chiffré

database:
  host: db.example.com  # Non chiffré (pas sensible)
  username: ENC[AES256_GCM,data:dUdUrO0=,iv:...,tag:...,type:str]
  password: ENC[AES256_GCM,data:GIwjxyzsbNqb,iv:...,tag:...,type:str]
sops:
  age:
    - recipient: age1jk54cwqnaw2utp7...
      enc: |
        -----BEGIN AGE ENCRYPTED FILE-----
        ...
        -----END AGE ENCRYPTED FILE-----
  lastmodified: "2026-01-23T16:15:05Z"
  version: 3.11.0

Avantage : vous pouvez reviewer les changements de structure (nouvelles clés, suppressions) sans avoir accès aux secrets.

Installation

Prérequis

SOPS nécessite un backend de chiffrement. Les options sont :

Backend	Usage recommandé	Avantage
age	Équipes, projets personnels	Simple, pas de service
AWS KMS	Projets AWS	IAM intégré
GCP KMS	Projets GCP	IAM intégré
Azure Key Vault	Projets Azure	Azure AD intégré
HashiCorp Vault	Entreprise	Transit encryption

Glissez pour voir

PGP déprécié

Le support de PGP pourrait disparaître dans les futures versions de SOPS (issue #727). Préférez age pour les nouveaux projets.

Installer SOPS

Linux

# Télécharger le binaire (v3.11.0)
curl -sLO https://github.com/getsops/sops/releases/download/v3.11.0/sops-v3.11.0.linux.amd64
chmod +x sops-v3.11.0.linux.amd64
sudo mv sops-v3.11.0.linux.amd64 /usr/local/bin/sops

# Vérifier
sops --version
# sops 3.11.0 (latest)

macOS

brew install sops

# Vérifier
sops --version

Windows

# Via Scoop
scoop install sops

# Ou télécharger depuis GitHub Releases
# https://github.com/getsops/sops/releases

asdf

asdf plugin add sops
asdf install sops latest
asdf global sops latest

sops --version

Installer age

Linux (v1.3.0)

# Télécharger age v1.3.0 (avec support post-quantum)
curl -sL https://github.com/FiloSottile/age/releases/download/v1.3.0/age-v1.3.0-linux-amd64.tar.gz | tar xz
sudo mv age/age age/age-keygen /usr/local/bin/
rm -rf age

# Vérifier
age --version
# v1.3.0

macOS

brew install age

age --version

Windows

scoop install age
# ou winget install FiloSottile.age

age 1.3.0 et post-quantum

La version 1.3.0 de age introduit le chiffrement post-quantum avec des clés commençant par age1pq1.... Cependant, SOPS ne supporte pas encore nativement ces clés PQ (à date de janvier 2026). Utilisez les clés standard age1... avec SOPS.

Pour le chiffrement PQ, age 1.3.0 reste compatible avec les fichiers existants et les clés standard.

Chiffrer avec age (recommandé)

Créer une clé age

1. Créer le répertoire pour les clés

   mkdir -p ~/.config/sops/age

2. Générer une clé

   age-keygen -o ~/.config/sops/age/keys.txt
   
   # Sortie :
   # Public key: age1jk54cwqnaw2utp7uwk6nvehr6rsfwrwulhf8kk9lxcw9qy92cf0qfu6nam

3. Sauvegarder la clé publique

   Notez la clé publique (age1...), vous en aurez besoin pour chiffrer. La clé privée est dans keys.txt.

Sauvegarde obligatoire

Sauvegardez keys.txt dans un gestionnaire de mots de passe (Bitwarden, 1Password, etc.). Si vous perdez cette clé, vos secrets sont irrécupérables.

Chiffrer un fichier

# Créer un fichier de test
cat > secrets.yaml << 'EOF'
database:
  host: db.example.com
  username: admin
  password: super-secret-123
api:
  token: sk-1234567890abcdef
EOF

# Chiffrer avec votre clé publique age
sops encrypt --age age1jk54cwqnaw2utp7uwk6nvehr6rsfwrwulhf8kk9lxcw9qy92cf0qfu6nam \
  secrets.yaml > secrets.enc.yaml

# Vérifier le résultat
cat secrets.enc.yaml

Déchiffrer un fichier

# SOPS cherche automatiquement dans ~/.config/sops/age/keys.txt
sops decrypt secrets.enc.yaml

# Ou spécifier le fichier de clé
SOPS_AGE_KEY_FILE=~/keys/ma-cle.txt sops decrypt secrets.enc.yaml

Éditer un fichier chiffré

# Ouvre le fichier déchiffré dans $EDITOR, re-chiffre à la sauvegarde
sops edit secrets.enc.yaml

Définir l'éditeur

export EDITOR=vim  # ou code, nano, etc.

Configuration multi-clés

Pour une équipe, vous voulez que plusieurs personnes puissent déchiffrer les secrets. SOPS supporte plusieurs clés dans un même fichier.

Ajouter plusieurs clés

# Chiffrer pour 2 personnes
sops encrypt \
  --age age1abc...,age1def... \
  secrets.yaml > secrets.enc.yaml

Chaque personne peut déchiffrer avec sa propre clé privée.

Fichier de configuration .sops.yaml

Pour éviter de spécifier les clés à chaque commande, créez .sops.yaml à la racine du projet :

.sops.yaml

creation_rules:
  # Secrets de production : équipe ops + KMS
  - path_regex: secrets/prod/.*\.yaml$
    key_groups:
      - age:
          - age1abc...  # Alice (ops)
          - age1def...  # Bob (ops)
        kms:
          - arn: arn:aws:kms:eu-west-1:123456:key/xxx

  # Secrets de dev : équipe dev
  - path_regex: secrets/dev/.*\.yaml$
    age: age1ghi...,age1jkl...

  # Par défaut : clé personnelle
  - age: age1mno...

Avec cette configuration :

# SOPS applique automatiquement les bonnes clés
sops encrypt secrets/prod/database.yaml > secrets/prod/database.enc.yaml

Chiffrer avec AWS KMS

Pour les projets AWS, utilisez KMS pour bénéficier de l’intégration IAM.

1. Créer une clé KMS

   aws kms create-key \
     --description "SOPS encryption key" \
     --tags TagKey=Purpose,TagValue=SOPS
   
   # Noter l'ARN : arn:aws:kms:eu-west-1:123456:key/xxx-xxx

2. Chiffrer avec KMS

   sops encrypt \
     --kms arn:aws:kms:eu-west-1:123456:key/xxx-xxx \
     secrets.yaml > secrets.enc.yaml

3. Déchiffrer (les credentials AWS sont utilisés automatiquement)

   sops decrypt secrets.enc.yaml

Combiner age et KMS

Vous pouvez utiliser plusieurs backends pour la redondance :

.sops.yaml

creation_rules:
  - path_regex: .*\.yaml$
    key_groups:
      - age:
          - age1abc...  # Backup local
        kms:
          - arn: arn:aws:kms:eu-west-1:123456:key/xxx

Si KMS est indisponible, la clé age permet toujours de déchiffrer.

Intégrations

SOPS et Ansible

La collection community.sops permet de déchiffrer les fichiers SOPS directement dans vos playbooks.

1. Installer la collection

   ansible-galaxy collection install community.sops

2. Utiliser le lookup

   ---
   - name: Déployer avec secrets SOPS
     hosts: all
     tasks:
       - name: Lire les secrets
         ansible.builtin.debug:
           msg: "{{ lookup('community.sops.sops', 'secrets.enc.yaml') }}"
   
       - name: Utiliser une valeur spécifique
         ansible.builtin.debug:
           msg: "Password: {{ (lookup('community.sops.sops', 'secrets.enc.yaml') | from_yaml).database.password }}"

3. Exporter la clé pour Ansible

   export SOPS_AGE_KEY_FILE=~/.config/sops/age/keys.txt
   ansible-playbook playbook.yml

SOPS et Kubernetes

L’opérateur sops-secrets-operator déchiffre automatiquement les SopsSecret en Secret Kubernetes.

apiVersion: isindir.github.com/v1alpha3
kind: SopsSecret
metadata:
  name: my-secret
spec:
  secretTemplates:
    - name: my-k8s-secret
      stringData:
        username: ENC[AES256_GCM,data:...]
        password: ENC[AES256_GCM,data:...]

SOPS et CI/CD

GitHub Actions

name: Deploy
on: push

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install SOPS
        run: |
          curl -sLO https://github.com/getsops/sops/releases/download/v3.11.0/sops-v3.11.0.linux.amd64
          chmod +x sops-v3.11.0.linux.amd64
          sudo mv sops-v3.11.0.linux.amd64 /usr/local/bin/sops

      - name: Decrypt secrets
        env:
          SOPS_AGE_KEY: ${{ secrets.SOPS_AGE_KEY }}
        run: |
          sops decrypt secrets.enc.yaml > secrets.yaml

GitLab CI

deploy:
  image: alpine:latest
  before_script:
    - apk add --no-cache curl
    - curl -sLO https://github.com/getsops/sops/releases/download/v3.11.0/sops-v3.11.0.linux.amd64
    - chmod +x sops-v3.11.0.linux.amd64 && mv sops-v3.11.0.linux.amd64 /usr/local/bin/sops
  script:
    - export SOPS_AGE_KEY="$SOPS_AGE_KEY"
    - sops decrypt secrets.enc.yaml > secrets.yaml
  variables:
    SOPS_AGE_KEY: $SOPS_AGE_KEY  # Variable CI/CD protégée

Stockage de la clé privée

En CI/CD, stockez la clé privée complète (contenu de keys.txt) dans une variable protégée, pas dans un fichier du repo.

Dépannage

Problème	Cause	Solution
no such file: keys.txt	Chemin de clé incorrect	Vérifier SOPS_AGE_KEY_FILE ou créer ~/.config/sops/age/keys.txt
could not decrypt	Clé privée non correspondante	Vérifier que votre clé publique est dans le fichier chiffré
failed to create writer for recipient: pq plugin	Clé PQ age 1.3.0	SOPS ne supporte pas les clés PQ, utilisez age1... standard
yaml: unmarshal errors	Format invalide	Vérifier la syntaxe YAML avant chiffrement
MAC mismatch	Fichier corrompu	Restaurer depuis Git

Glissez pour voir

Vérifier les clés d’un fichier

# Voir qui peut déchiffrer
sops decrypt --show-all-keys secrets.enc.yaml 2>&1 | grep -E "age|kms"

Ajouter/retirer une clé

# Ajouter une clé à un fichier existant
sops updatekeys --add-age age1newkey... secrets.enc.yaml

# Retirer une clé
sops updatekeys --rm-age age1oldkey... secrets.enc.yaml

Rotation de clé

# Re-chiffrer avec de nouvelles clés
sops rotate -i secrets.enc.yaml

Bonnes pratiques

• Une clé par personne : chaque membre de l’équipe a sa propre clé age, ce qui facilite la révocation quand quelqu’un part
• Sauvegarder les clés : stockez les clés privées dans un gestionnaire de mots de passe (perte de clé = secrets irrécupérables)
• .sops.yaml versionné : committez ce fichier pour que toute l’équipe utilise les mêmes règles
• KMS en production : combinez age (backup) + KMS (rotation automatique, audit)

Pattern de structure recommandé

• Répertoireproject/

  • .sops.yaml Configuration des clés
  • Répertoiresecrets/

    • Répertoiredev/

      • database.enc.yaml
    • Répertoireprod/

      • database.enc.yaml
  • README.md Instructions pour l’équipe

À retenir

1. SOPS chiffre les valeurs, pas les clés : les diffs Git restent lisibles
2. age est recommandé : simple, pas de service, compatible partout
3. PGP est déprécié : migrez vers age pour les nouveaux projets
4. age 1.3.0 post-quantum : non supporté par SOPS (janvier 2026), utilisez les clés standard
5. Multi-clés natif : chaque membre de l’équipe a sa clé, révocation facile
6. .sops.yaml : centralisez la configuration des clés dans le repo
7. KMS pour la prod : audit, rotation automatique, intégration IAM

Prochaines étapes

HashiCorp Vault Gestion centralisée des secrets avec API et policies avancées

Ansible Vault Chiffrement natif pour les playbooks Ansible

Infisical Alternative open source à Vault avec UI moderne

Cosign : signer vos images Complétez SOPS avec la signature de vos artefacts

Ressources

• Documentation officielle : getsops.io
• GitHub : getsops/sops
• age : github.com/FiloSottile/age
• Collection Ansible : community.sops
• Kubernetes Operator : sops-secrets-operator

×

📖 Voir la documentation →