---
title: "Stockage cloud : blocs, fichiers et objets"
domain: cloud-computing
level: beginner
duration: "50 min"
objectives:
  - "Comparer le stockage en blocs, de fichiers et d'objets selon la méthode d'accès, les performances, le partage et les cas d'usage typiques."
  - "Expliquer la différence entre durabilité et disponibilité, comment la réplication et le codage d'effacement (erasure coding) protègent les données, et ce que les classes de stockage arbitrent."
  - "Utiliser le stockage d'objets via l'API S3 : créer des buckets, téléverser et lister des objets, activer le versionnement et ajouter des règles de cycle de vie."
  - "Partager un objet en toute sécurité avec une URL pré-signée et expliquer pourquoi les buckets publics sont risqués."
  - "Expliquer les instantanés, les sauvegardes et le chiffrement au repos et en transit, et qui gère les clés."
lang: fr
source_hash: a31a7d7731b3
---

# Stockage cloud : blocs, fichiers et objets

## Pourquoi c'est important
Une petite équipe lance une application de partage de photos. Elle conserve les photos sur le disque de la machine virtuelle qui exécute l'application, parce que c'est ce qu'il y a de plus simple. Trois mois plus tard, l'application a besoin d'un deuxième serveur, et ce deuxième serveur ne voit pas les photos du premier. Puis le disque se remplit. Puis un développeur lance un script de nettoyage sur le mauvais dossier, et il n'existe aucune copie à restaurer.

Chaque problème appelle une réponse de stockage différente. Les photos relèvent du **stockage d'objets**, que n'importe quel nombre de serveurs peut atteindre par le réseau et qui grandit sans que vous ayez à le planifier. La base de données a besoin d'un **volume de blocs** rapide. Le dossier de configuration partagé convient à un **partage de fichiers**. Et rien de tout cela n'est sûr tant que le versionnement, les sauvegardes et le chiffrement ne sont pas en place. Les fournisseurs de cloud vendent tout cela sous des marques différentes. Cette leçon vous donne le modèle neutre vis-à-vis des fournisseurs qui se cache derrière, afin de choisir le bon type de stockage et d'éviter les erreurs classiques : confondre durabilité et sauvegarde, et laisser un bucket public.

## Objectifs pédagogiques
- Comparer le stockage en blocs, de fichiers et d'objets selon la méthode d'accès, les performances, le partage et les cas d'usage typiques.
- Expliquer la différence entre durabilité et disponibilité, comment la réplication et le codage d'effacement (erasure coding) protègent les données, et ce que les classes de stockage arbitrent.
- Utiliser le stockage d'objets via l'API S3 : créer des buckets, téléverser et lister des objets, activer le versionnement et ajouter des règles de cycle de vie.
- Partager un objet en toute sécurité avec une URL pré-signée et expliquer pourquoi les buckets publics sont risqués.
- Expliquer les instantanés, les sauvegardes et le chiffrement au repos et en transit, et qui gère les clés.

## Concepts clés

### Trois types de stockage : blocs, fichiers et objets
Pensez aux trois manières de ranger des documents papier. Le **stockage en blocs** est un classeur vide : c'est à vous de décider comment tout étiqueter et organiser. Le **stockage de fichiers** est une armoire de bureau partagée, avec des tiroirs étiquetés que tous les membres de l'équipe peuvent ouvrir. Le **stockage d'objets** est un entrepôt avec un employé : vous lui remettez une boîte, vous recevez un numéro de ticket, et vous présentez plus tard ce ticket pour récupérer la boîte.

Le **stockage en blocs** expose un **volume** : un tableau de blocs numérotés, de taille fixe, qu'un serveur voit comme un disque brut, par exemple `/dev/vdb` sous Linux. Le système d'exploitation y place un **système de fichiers** (ext4, XFS, NTFS), ou une base de données l'utilise directement. Vous attachez un volume à une seule instance à la fois (certains fournisseurs proposent un mode d'attachement multiple, mais il faut alors un système de fichiers conçu pour les clusters, sous peine de corrompre les données). Le stockage en blocs se juge sur trois chiffres :

- **IOPS** (opérations d'entrée/sortie par seconde, input/output operations per second) : le nombre de lectures et d'écritures par seconde.
- **Débit** (throughput) : le nombre d'octets par seconde. Il est égal aux IOPS multipliées par la taille de chaque opération. Par exemple, 3 000 IOPS de 16 KiB chacune font 48 000 KiB/s, soit environ 47 MiB/s.
- **Latence** : la durée d'une opération, généralement de moins de quelques millisecondes.

Le **stockage de fichiers** est un système de fichiers partagé, servi par le réseau. De nombreux serveurs montent en même temps le même partage grâce au **Network File System (NFS)**, courant sous Linux (NFSv4.1 est défini dans la RFC 8881), ou au protocole **Server Message Block (SMB)**, courant sous Windows. Le service gère le système de fichiers : vous disposez donc de répertoires, de permissions, de verrouillage de fichiers et de la **sémantique POSIX** (les règles de l'interface de système d'exploitation portable, Portable Operating System Interface, pour les fichiers : on peut ajouter des données à la fin d'un fichier, le renommer de façon atomique, modifier un octet au milieu et verrouiller une région). Le stockage de fichiers est donc le choix naturel pour les logiciels écrits pour des dossiers ordinaires : répertoires personnels, systèmes de gestion de contenu et artefacts de compilation partagés.

Le **stockage d'objets** conserve des **objets** (des données plus des métadonnées) dans des **buckets**. On ne le monte jamais : les applications le sollicitent par une interface de programmation d'application (API) via le protocole de transfert hypertexte (HTTP, Hypertext Transfer Protocol), avec des requêtes comme `PUT`, `GET`, `LIST` et `DELETE`. Il n'y a pas de répertoires à entretenir et pas de limite réelle au nombre d'objets, ce qui explique qu'il passe à l'échelle sur des milliers de machines et coûte moins cher par gigaoctet que les deux autres. Le prix à payer est le modèle d'accès : un objet s'écrit et se lit en entier. On ne peut ni modifier un octet sur place ni renommer un objet ; on téléverse une nouvelle copie.

![Trois colonnes. Stockage en blocs : une instance monte un volume comme périphérique de blocs (par exemple /dev/vdb sur /data) et lit et écrit des blocs à un décalage donné ; le volume contient des blocs bruts et l'instance crée le système de fichiers ; pastilles IOPS, latence, bases de données. Stockage de fichiers : de nombreuses instances montent le même partage via NFS ou SMB avec des fichiers et des chemins ; le service gère le système de fichiers ; pastilles partagé, POSIX, dossiers personnels. Stockage d'objets : toute application disposant d'identifiants envoie des requêtes HTTPS PUT, GET et LIST à un bucket qui associe une clé à un objet et à ses métadonnées dans un espace de noms plat ; pastilles passage à l'échelle, bon marché, sauvegardes et médias](../../../assets/diagrams/storage-access-paths.fr.svg)

*Figure 1. Les trois types de stockage diffèrent par celui qui gère le système de fichiers et par la façon dont un client atteint les données : des blocs, des fichiers et des chemins, ou des requêtes HTTP portant sur des objets entiers.*

| | Blocs | Fichiers | Objets |
|---|---|---|---|
| Méthode d'accès | Blocs bruts via le système d'exploitation (`/dev/vdb`) | Montage NFS ou SMB | API HTTP (de type S3) |
| Unité de données | Bloc (par exemple 4 KiB) | Fichier dans un répertoire | Objet entier, jusqu'à une limite fixée par le fournisseur |
| Partage | Une instance à la fois | De nombreuses instances | Tout client disposant d'identifiants |
| Modification sur place | Oui | Oui | Non : on remplace l'objet entier |
| Points forts | Latence la plus faible, IOPS les plus élevées | Dossiers familiers, POSIX | Passage à l'échelle, durabilité, faible coût par Go |
| Usage typique | Bases de données, disques de démarrage | Dossiers partagés, applications héritées | Photos, sauvegardes, journaux, sites web statiques, lacs de données |
| Exemples cloud | Amazon EBS, Azure Managed Disks, Google Persistent Disk | Amazon EFS, Azure Files, Google Filestore | Amazon S3, Azure Blob Storage, Google Cloud Storage |

> [!CHECK]
> Un serveur de base de données a besoin de la latence la plus faible possible et effectue de nombreuses petites écritures aléatoires. Quel type de stockage convient le mieux ?
>
> - [ ] Le stockage d'objets, car il passe à l'échelle sans limite
> - [ ] Le stockage de fichiers, car plusieurs serveurs peuvent le monter en même temps
> - [x] Un volume de blocs attaché à l'instance de la base de données
> - [ ] N'importe lequel : le type ne change que le prix
>
> Les volumes de blocs donnent un accès direct, à faible latence, à un décalage donné, et sont dimensionnés pour les IOPS. Le stockage d'objets remplace des objets entiers via HTTP, et un partage de fichiers réseau ajoute un surcoût de protocole et des fonctions de partage dont une base de données unique n'a pas besoin.

### Stockage d'objets : buckets, clés et API S3
Un **bucket** est un conteneur nommé pour des objets. Un objet possède une **clé** (son nom), les données (une suite d'octets) et des **métadonnées** : des champs système comme la taille, le type de contenu et la date de dernière modification, plus des paires clé-valeur personnalisées que vous ajoutez, comme `project=apollo`. Les noms de bucket sont uniques chez un fournisseur (ou dans une région, selon le fournisseur), car ils apparaissent généralement dans une URL.

L'espace de noms est **plat** : un bucket contient des clés, pas des dossiers. Une clé comme `reports/2026/q3.txt` est une seule chaîne de caractères qui se trouve contenir des barres obliques. La partie qui précède une barre oblique s'appelle un **préfixe**, et un listage avec un délimiteur (`/`) permet aux outils et aux consoles d'*afficher* des dossiers. Mais il n'existe pas d'objet répertoire `reports/` à créer, à renommer ou à remplir : si vous supprimez le dernier objet sous un préfixe, le « dossier » disparaît. Renommer un « dossier » revient à copier puis supprimer chaque objet placé sous le préfixe.

Les applications atteignent les objets par du HTTP simple. Une requête de téléversement et une requête de téléchargement ressemblent à ceci (le nom d'hôte est un exemple) :

```text
PUT /reports/2026/q3.txt HTTP/1.1
Host: lab-docs.objects.example.com
Content-Type: text/plain
x-amz-meta-project: apollo
Authorization: <signature computed from your secret key>

Quarterly report v1
```

```text
GET /reports/2026/q3.txt HTTP/1.1
Host: lab-docs.objects.example.com
Authorization: <signature computed from your secret key>
```

La plupart des fournisseurs acceptent le bucket soit dans le nom d'hôte (`lab-docs.objects.example.com`, style « virtual-hosted »), soit comme premier segment du chemin (`objects.example.com/lab-docs/…`, style « path »). L'en-tête `Authorization` contient une signature produite avec votre clé d'accès : le service sait ainsi qui fait la demande, et personne d'autre ne peut réutiliser la requête. Les gros objets sont téléversés en plusieurs parties (un **téléversement multipartie**, multipart upload), qui peuvent être relancées indépendamment.

L'**API S3** est l'interface HTTP d'Amazon Simple Storage Service (S3). Elle est devenue le standard de fait du stockage d'objets : de nombreux fournisseurs (par exemple Backblaze B2, Cloudflare R2, Wasabi, et Google Cloud Storage via son mode d'interopérabilité) et des serveurs open source (Ceph RADOS Gateway, SeaweedFS, Garage) l'implémentent, tout comme des émulateurs pour les tests, tel Moto, que vous utilisez dans le lab. Les mêmes kits de développement et les mêmes outils en ligne de commande fonctionnent avec tous ; seuls l'URL du point de terminaison et les clés changent. Chaque implémentation couvre un sous-ensemble différent de fonctions : testez celles dont vous dépendez.

> [!NOTE]
> « Compatible S3 » est une affirmation, pas une certification. Les appels de base (créer un bucket, put, get, list, delete) fonctionnent presque partout. Le versionnement, les règles de cycle de vie, les politiques de bucket, les options de chiffrement et les notifications d'événements diffèrent d'une implémentation à l'autre. Consultez la page de compatibilité du fournisseur avant de vous appuyer sur une fonction.

De nombreux magasins d'objets modernes, dont Amazon S3 depuis décembre 2020, offrent une **cohérence forte en lecture après écriture** : dès qu'un `PUT` réussit, le `GET` ou le `LIST` suivant renvoie les nouvelles données. Les systèmes plus anciens et certains serveurs compatibles n'étaient que cohérents à terme : vérifiez donc ce point aussi.

> [!CHECK]
> Un bucket contient les clés `logs/2026/01.txt` et `logs/2026/02.txt`. Vous supprimez les deux objets. Qu'advient-il du dossier `logs/` ?
>
> - [ ] Il reste comme dossier vide, et vous devez le supprimer séparément
> - [ ] La suppression échoue, car le dossier n'est pas vide
> - [x] Il ne reste rien : `logs/` n'était qu'un préfixe commun dans les noms de clés, pas un objet
> - [ ] Il est déplacé dans un dossier corbeille à l'intérieur du bucket
>
> Le stockage d'objets a un espace de noms plat. Les barres obliques sont des caractères ordinaires de la clé, et les consoles ne dessinent des dossiers qu'en regroupant les clés qui partagent un préfixe.

### Durabilité, disponibilité et protection des données
Deux mots qui se ressemblent promettent des choses différentes.

- La **durabilité** est la probabilité que les données ne soient ni perdues ni corrompues au fil du temps.
- La **disponibilité** est la fraction du temps pendant laquelle le service répond aux requêtes.

Les fournisseurs expriment souvent la durabilité en « onze neuf » : 99,999999999 %. Il s'agit généralement d'un chiffre annuel par objet. La probabilité de perdre un objet donné en un an est d'environ 1 sur 100 milliards : si vous stockiez 10 millions d'objets, vous devriez en perdre un environ tous les 10 000 ans. La disponibilité est bien plus faible et constitue une autre promesse : 99,9 % autorise environ 8,8 heures d'indisponibilité par an, 99,99 % environ 53 minutes.

Ce que les onze neuf **ne signifient pas** :

- Ils ne signifient pas que les données sont accessibles à l'instant même. Une panne rend les données indisponibles, pas perdues.
- Ils ne vous protègent pas contre vous-même : si vous ou un attaquant supprimez un objet, l'écrasez ou supprimez le bucket, le service conserve durablement la suppression.
- C'est un objectif de conception, appuyé sur un modèle statistique des pannes de disque, et non une garantie contractuelle. Les accords de niveau de service (SLA, service-level agreements) offrent généralement des crédits de service pour la disponibilité, pas une récupération des données.
- Ils ne couvrent pas les événements corrélés que le modèle ignore, comme un bogue logiciel, une erreur d'opérateur ou un compte cloud perdu.

> [!NOTE]
> Les chiffres exacts de durabilité et de disponibilité, et ce que le SLA indemnise, diffèrent selon le fournisseur, la classe de stockage et la région, et ils évoluent. Lisez la documentation actuelle du fournisseur plutôt que de vous fier à un chiffre dont vous vous souvenez.

Les fournisseurs atteignent une durabilité élevée en conservant les données de manière redondante sur des domaines de défaillance indépendants : disques, serveurs, baies et **zones de disponibilité** (centres de données distincts au sein d'une région). Ils emploient deux techniques principales.

La **réplication** stocke plusieurs copies complètes, par exemple trois copies dans trois zones. Elle est simple, les lectures sont rapides (n'importe quelle copie peut les servir) et une copie perdue est simplement recopiée. Le coût est la capacité : trois copies représentent 3 fois la capacité brute.

Le **codage d'effacement** (erasure coding) découpe un objet en *k* fragments de données et calcule à partir d'eux *m* fragments de parité, généralement avec un code de Reed-Solomon. N'importe quels *k* fragments parmi les *k + m* suffisent à reconstruire l'objet. Avec 4 fragments de données et 2 de parité (noté « 4+2 »), le système survit à la perte de deux fragments quelconques en ne stockant que 1,5 fois les données. Les contreparties sont le temps du processeur (CPU, central processing unit) pour l'encodage, davantage de trafic réseau pour reconstruire un fragment perdu, et une latence supplémentaire pour les petits objets (de nombreux systèmes répliquent les données petites ou fréquemment lues et appliquent le codage d'effacement aux données volumineuses ou froides).

![À gauche, la réplication : un objet de 12 Mo est stocké en trois copies complètes, une dans chacune des zones A, B et C ; surcoût 3x, survit à la perte de 2 copies, lectures simples et rapides. À droite, le codage d'effacement avec 4 fragments de données et 2 de parité : le même objet est découpé en six fragments de 3 Mo, D1 à D4 de données et P1 et P2 de parité ; D2 et P1 sont représentés comme perdus et l'objet est reconstruit à partir des quatre autres ; surcoût 1,5x, 4 fragments quelconques sur 6 reconstruisent l'objet](../../../assets/diagrams/storage-replication-erasure.fr.svg)

*Figure 2. La réplication achète la simplicité au prix de la capacité ; le codage d'effacement offre une protection comparable pour moitié moins de surcoût.*

Les volumes de blocs sont généralement répliqués à l'intérieur d'une seule zone : un volume survit donc à la panne d'un disque, mais pas à la perte d'une zone. Pour une protection au niveau de la zone, vous copiez les données ailleurs (instantanés, réplication vers une autre région).

> [!CHECK]
> Un fournisseur annonce une durabilité de 99,999999999 % pour un bucket. Vous exécutez par erreur un script qui supprime tous les objets du bucket. Que vous apprend ce chiffre sur la possibilité de récupérer les données ?
>
> - [ ] Le fournisseur restaurera tous les objets, car les données ne peuvent pas être perdues
> - [ ] Les objets restent récupérables tant que le bucket existe
> - [x] Rien : la durabilité concerne les pertes matérielles, et le service stocke durablement aussi votre suppression
> - [ ] Seul le chiffre de disponibilité compte ici
>
> La durabilité protège contre les pannes de disques, de serveurs et de zones. Elle n'annule pas les suppressions ni les écrasements effectués avec des identifiants valides. Le versionnement et les sauvegardes, si.

### Classes de stockage, versionnement et règles de cycle de vie
Toutes les données ne sont pas lues aussi souvent. Les téléversements de la semaine dernière sont lus chaque jour ; un journal d'audit vieux de sept ans n'est presque jamais lu. Une **classe de stockage** (ou **niveau**, tier) vous permet de payer selon la fréquence d'accès aux données. Les noms varient selon les fournisseurs (Amazon S3 Standard, Standard-IA et Glacier ; Azure Hot, Cool et Archive ; Google Standard, Nearline, Coldline et Archive), mais le modèle est le même :

| Niveau | Coût de stockage | Récupération | Usage typique |
|---|---|---|---|
| Chaud / standard | Le plus élevé | Gratuite ou très peu chère, en millisecondes | Données actives, sites web, ressources d'application |
| Accès peu fréquent / tiède | Plus faible | Frais de récupération par Go, toujours en millisecondes | Sauvegardes lues de temps à autre, médias plus anciens |
| Archive / froid | Le plus faible | Frais de récupération plus élevés, de quelques minutes à quelques heures (une demande de restauration d'abord) | Documents de conformité, sauvegardes à long terme |

Les niveaux plus froids déplacent le coût du stockage vers la lecture : peu cher par gigaoctet et par mois, mais avec des frais de récupération, une **durée minimale de stockage** (une suppression anticipée est tout de même facturée), parfois une **taille minimale d'objet**, et un premier accès plus lent. Archiver un jeu de données que vous lisez chaque semaine peut coûter plus cher que le garder au niveau chaud. La durabilité est généralement la même d'une classe à l'autre ; la disponibilité et la récupération diffèrent.

> [!NOTE]
> Les prix, les durées minimales, les tailles minimales et les délais de récupération évoluent et diffèrent selon le fournisseur ; cette leçon n'en donne donc aucun. Consultez toujours la grille tarifaire actuelle et modélisez votre propre schéma d'accès avant de déplacer des données vers un niveau plus froid.

Une **règle de cycle de vie** automatise cela. Vous écrivez la politique une fois et le service l'applique : « sous `tmp/`, supprimer les objets 30 jours après leur création » ; « déplacer les objets vers le niveau tiède après 60 jours et vers l'archive après 365 » ; « supprimer les versions non courantes après 90 jours ». Les règles sélectionnent les objets par préfixe, étiquette ou taille. Elles s'exécutent en arrière-plan, généralement une fois par jour : un objet peut donc vivre un peu plus longtemps que la durée exacte que vous avez fixée.

Le **versionnement** protège contre les écrasements et les suppressions. Lorsque vous l'activez sur un bucket, chaque `PUT` vers une clé existante crée une nouvelle **version** avec son propre identifiant de version au lieu de remplacer l'objet, et les anciennes versions restent. Un `DELETE` simple ne supprime aucune donnée : il ajoute un **marqueur de suppression**, un substitut de zéro octet qui devient la version courante. Comme la version courante est un marqueur de suppression, `GET` renvoie « introuvable » et la clé disparaît des listages normaux, mais les versions antérieures sont intactes. Pour annuler, vous supprimez le marqueur ou recopiez une version plus ancienne pour qu'elle devienne la version courante. Pour vraiment effacer des données, vous supprimez un identifiant de version précis.

![Quatre étapes sur un bucket dont le versionnement est activé. 1 : PUT notes.txt crée la version v1. 2 : un nouveau PUT notes.txt crée la version v2. 3 : DELETE notes.txt ajoute un marqueur de suppression. 4 : recopier v1 crée la version v4, copie de v1. Après l'étape 3, le bucket contient le marqueur de suppression (courant), v2 et v1, et GET renvoie 404 Not Found bien que v1 et v2 existent toujours. Après l'étape 4, il contient v4 (courante), le marqueur de suppression, v2 et v1, et GET renvoie le contenu de v1](../../../assets/diagrams/storage-versioning.fr.svg)

*Figure 3. Avec le versionnement, une suppression ne fait que masquer l'objet derrière un marqueur. Restaurer, c'est rendre à nouveau courante une version plus ancienne.*

Le versionnement a un coût : chaque version est stockée et facturée. Associez-le à une règle de cycle de vie qui fait expirer les versions non courantes après un nombre de jours défini, faute de quoi le bucket grossit indéfiniment. Sur Amazon S3, le versionnement ne peut pas être désactivé une fois activé, seulement suspendu ; vérifiez ce qu'il en est chez votre fournisseur.

> [!CHECK]
> Le versionnement est activé. Vous téléversez `notes.txt` deux fois, puis vous le supprimez par une requête de suppression normale. Que contient le bucket ?
>
> - [ ] Rien : une suppression retire toutes les versions
> - [ ] Seulement la deuxième version, car la première a été écrasée
> - [x] Les deux versions plus un marqueur de suppression, qui donne à la clé l'apparence d'une clé supprimée
> - [ ] Une seule copie du fichier dans le niveau d'archive
>
> Une suppression sur un bucket versionné ajoute un marqueur de suppression. Les lectures normales voient « introuvable », mais les deux versions subsistent jusqu'à ce que vous les supprimiez par identifiant de version ou qu'une règle de cycle de vie les fasse expirer.

### Partager des objets et contrôler l'accès
Un nouveau bucket est **privé** : seul le compte qui le possède, et les principaux auxquels il a accordé l'accès, peuvent le lire. (Les identités, les rôles et les politiques font l'objet du [module 07](../07-cloud-iam/README.fr.md).) Il existe trois façons de laisser entrer d'autres personnes, de la plus sûre à la plus risquée.

Une **URL pré-signée** donne un accès limité dans le temps à un seul objet sans partager d'identifiants. Votre application utilise sa clé secrète pour calculer une signature portant sur la méthode HTTP, le chemin de l'objet et une heure d'expiration, et l'ajoute à l'URL. Quiconque détient l'URL peut effectuer cette seule opération (généralement `GET` ou `PUT`) jusqu'à son expiration. La signature est calculée localement, sans appel au service. Le service vérifie la signature, l'expiration et que le signataire est toujours autorisé à lire l'objet. Usages typiques : un lien de téléchargement dans un courriel, ou permettre à un navigateur de téléverser une photo directement dans le bucket plutôt que via votre serveur. Gardez des expirations courtes, traitez l'URL comme un secret (elle apparaît dans les journaux et l'historique du navigateur), et n'oubliez pas qu'elle peut cesser de fonctionner plus tôt si les identifiants de signature sont temporaires et expirent en premier.

![Une séquence à trois acteurs : l'application qui détient les identifiants, le service de stockage d'objets dont le bucket reste privé, et un destinataire sans identifiants. 1 : l'application signe localement avec sa clé secrète la méthode, le chemin et l'expiration ; aucune requête n'est envoyée au service. 2 : elle partage l'URL, valable 5 minutes, avec le destinataire. 3 : le destinataire envoie GET avec la signature dans la chaîne de requête ; le service recalcule la signature, vérifie l'expiration et vérifie que le signataire peut lire l'objet. 4 : le service répond 200 OK avec les octets de l'objet, ou 403 Forbidden si l'URL a expiré ou a été modifiée](../../../assets/diagrams/storage-presigned-url.fr.svg)

*Figure 4. Une URL pré-signée est une capacité : quiconque la détient peut l'utiliser jusqu'à son expiration, et le bucket n'a jamais besoin de devenir public.*

Une **politique de bucket** est un document JavaScript Object Notation (JSON) attaché au bucket, qui indique qui peut faire quoi sur quels objets : les principaux, les actions (comme `s3:GetObject`), les ressources et des conditions facultatives. Utilisez-la pour des règles durables, par exemple « cet autre compte peut lire `reports/*` » ou « refuser toute requête qui ne passe pas par HTTPS ». C'est une politique fondée sur la ressource ; les politiques fondées sur l'identité, attachées aux utilisateurs et aux rôles, fonctionnent en complément.

Un **bucket public** (ou un objet public) est lisible par n'importe qui sur Internet, sans signature, parce qu'une politique ou une liste de contrôle d'accès (ACL, access control list) accorde l'accès au principal `*` (« tout le monde »). C'est la cause la plus fréquente de fuites de données dans le cloud : une politique prévue pour les images d'un site web, appliquée trop largement, expose des exports de clients ; des scanners automatiques recherchent en permanence des buckets ouverts. Pour l'éviter, les fournisseurs proposent le **blocage de l'accès public** (block public access), un interrupteur au niveau du bucket (et souvent du compte ou de l'organisation) qui l'emporte sur toute politique ou ACL qui rendrait les données publiques. Laissez-le activé partout, et ne le désactivez que pour un bucket qui est délibérément un site web public, idéalement derrière un réseau de diffusion de contenu (CDN, content delivery network) plutôt qu'en servant directement le bucket.

> [!CHECK]
> Un partenaire doit télécharger un rapport depuis votre bucket privé cet après-midi. Il n'a pas de compte chez vous. Quelle est l'option la plus sûre ?
>
> - [ ] Rendre tout le bucket public et envoyer le lien
> - [ ] Partager votre clé d'accès et votre clé secrète pour qu'il utilise la CLI
> - [x] Générer une URL pré-signée pour cet objet, avec une courte expiration
> - [ ] Ajouter une politique de bucket qui autorise le principal `*` à tout lire
>
> Une URL pré-signée accorde une opération sur un objet pour une durée limitée, grâce à votre signature mais sans jamais révéler vos clés, et le bucket reste privé.

### Instantanés, sauvegardes et chiffrement
Un **instantané** (snapshot) est une copie à un instant donné d'un volume (ou d'un partage de fichiers), réalisée sans le détacher. Les instantanés sont généralement incrémentiels : après le premier, seuls les blocs modifiés sont stockés, ce qui les rend rapides et peu coûteux. C'est le moyen rapide de revenir en arrière après une mauvaise mise à niveau ou de cloner un disque. Par défaut, toutefois, un instantané reste chez le même fournisseur, dans le même compte et la même région que le volume. Un instantané est **cohérent après plantage** (crash-consistent, comme si l'on débranchait le cordon d'alimentation) sauf si vous mettez l'application au repos au préalable, par exemple en vidant les écritures en attente de la base de données.

Une **sauvegarde** est une copie indépendante qui survit à la perte de l'original *et* du compte, de la région ou du système qui le contenait. La différence tient au domaine de défaillance : si la même erreur, le même rançongiciel ou la même compromission de compte peut supprimer à la fois les données et leurs copies, vous avez une copie, pas une sauvegarde. Le guide classique est la **règle 3-2-1** :

- **3** copies de vos données (l'original plus deux sauvegardes),
- sur **2** types de stockage ou de services différents,
- avec **1** copie hors site (une autre région, un autre fournisseur ou hors ligne).

La pratique moderne y ajoute une copie immuable (verrouillage d'objet, object lock, ou stockage WORM, write-once-read-many : un stockage qui ne peut être ni modifié ni supprimé avant une date de rétention) et, surtout, des **tests de restauration** : une sauvegarde que vous n'avez pas restaurée est un espoir, pas une sauvegarde. Les instantanés constituent une bonne première couche, et la règle 3-2-1 en demande davantage.

Le **chiffrement au repos** protège les données stockées : si quelqu'un obtient les disques ou une copie du stockage, il n'obtient que du texte chiffré. Le stockage cloud peut chiffrer chaque objet et chaque volume avec une clé symétrique (généralement Advanced Encryption Standard, AES, en 256 bits). Ce qui diffère, c'est qui détient la clé :

| Modèle de clés | Qui gère la clé | Remarques |
|---|---|---|
| Clés gérées par le fournisseur | Le fournisseur, de manière transparente | Souvent activé par défaut ; aucune configuration ; vous ne pouvez ni contrôler ni auditer l'utilisation de la clé |
| Clés gérées par le client | Vous, dans le **service de gestion de clés (KMS, key management service)** du fournisseur | Vous définissez la politique de la clé, la renouvelez et voyez chaque utilisation dans le journal d'audit ; désactiver ou supprimer la clé rend les données illisibles |
| Clés côté client ou fournies par le client | Vous, en dehors du fournisseur | Le fournisseur ne voit jamais la clé ni les données en clair ; contrôle le plus fort, mais vous devez garder la clé en lieu sûr sous peine de perdre les données |

Les services utilisent le **chiffrement d'enveloppe** (envelope encryption) : une clé de données unique chiffre chaque objet, et la clé du KMS chiffre (« enveloppe ») la clé de données. Seule la petite clé enveloppée est envoyée au KMS, ce qui le garde rapide et garde la clé maître à l'intérieur du KMS. Le chiffrement au repos n'empêche pas un utilisateur autorisé de lire les données : le service les déchiffre pour toute personne que la politique autorise ; il protège donc contre le vol de supports et certains risques internes, pas contre des permissions mal configurées.

Le **chiffrement en transit** protège les données sur le réseau. Utilisez **Transport Layer Security (TLS)**, le protocole qui sous-tend HTTPS (TLS 1.3 est la RFC 8446), pour chaque appel à une API de stockage, et montez les partages de fichiers réseau avec le chiffrement activé (NFS sur TLS, chiffrement SMB). Sans cela, n'importe qui sur le trajet peut lire ou modifier les données. La plupart des fournisseurs peuvent l'imposer au moyen d'une politique de bucket qui rejette le HTTP non chiffré.

> [!CHECK]
> Votre volume a un instantané quotidien, stocké dans le même compte et la même région. Un attaquant disposant d'identifiants d'administrateur volés supprime le volume. Pourquoi l'instantané n'est-il pas une sauvegarde suffisante ?
>
> - [ ] Les instantanés ne peuvent pas être restaurés vers de nouveaux volumes
> - [ ] Les instantanés ne sont jamais chiffrés
> - [x] Les mêmes identifiants peuvent aussi supprimer les instantanés : la copie partage le domaine de défaillance
> - [ ] Les instantanés ne sont conservés que 24 heures
>
> Une sauvegarde doit survivre à la perte du compte ou de la région qui détient l'original. La règle 3-2-1 demande au moins une copie ailleurs, idéalement immuable.

## Comment ça marche
Suivez un téléversement et un téléchargement d'un objet privé, pour voir comment les pièces s'emboîtent.

1. **Le client signe la requête.** Le kit de développement logiciel (SDK, software development kit) ou l'interface en ligne de commande (CLI, command-line interface) construit la requête HTTP, calcule l'empreinte de ses en-têtes et de son corps, et les signe avec votre clé secrète (AWS Signature Version 4 est le schéma habituel). La clé secrète n'est jamais envoyée ; la signature et votre identifiant de clé d'accès le sont.
2. **Le service authentifie et autorise.** Il retrouve votre secret à partir de l'identifiant de clé d'accès, recalcule la signature, puis évalue les politiques fondées sur l'identité, la politique de bucket et le blocage de l'accès public pour décider si l'action est autorisée.
3. **Les données sont placées et protégées.** Le service découpe l'objet, écrit des réplicas ou des fragments codés par effacement sur des disques de plusieurs zones, et stocke les métadonnées dans un index. Si le versionnement est activé, il enregistre un nouvel identifiant de version.
4. **Le service répond.** Ce n'est qu'une fois suffisamment de fragments stockés en sécurité qu'il renvoie `200 OK` et un **ETag** (un identifiant du contenu, souvent son empreinte Message-Digest 5, MD5, pour les téléversements simples) : un téléversement réussi est donc déjà durable.
5. **Un téléchargement suit le chemin inverse.** Le service vérifie la signature (ou la signature de la chaîne de requête d'une URL pré-signée) et les permissions, lit assez de fragments pour reconstruire l'objet, et le renvoie en flux sur TLS. Pour un objet du niveau d'archive, la première réponse est une erreur tant que vous n'avez pas demandé de restauration.

Pendant ce temps, des tâches d'arrière-plan appliquent les règles de cycle de vie, déplacent les objets entre niveaux, font expirer les anciennes versions et réparent les fragments perdus.

> [!CHECK]
> Dans le flux de téléversement, quand le service répond-il `200 OK` au client ?
>
> - [ ] Dès l'arrivée du premier octet, puis il stocke le reste plus tard
> - [x] Une fois l'objet stocké de façon redondante, de sorte que le succès signifie déjà qu'il est durable
> - [ ] Une fois que la tâche quotidienne de cycle de vie l'a traité
> - [ ] Seulement quand un deuxième client l'a lu
>
> Les magasins d'objets n'accusent réception d'une écriture qu'une fois suffisamment de copies ou de fragments stockés en sécurité. Les tâches de cycle de vie et les déplacements entre niveaux ont lieu plus tard, en arrière-plan.

## Exemple concret
Vous concevez le stockage de l'application de partage de photos du début de la leçon. Elle compte 2 TB de photos, qui augmentent de 100 GB par mois, une base de données PostgreSQL et un dossier partagé de modèles de configuration.

| Données | Stockage | Classe et protection | Pourquoi |
|---|---|---|---|
| Photos et miniatures | Bucket de stockage d'objets `photos-prod` | Standard pendant 30 jours, puis accès peu fréquent via une règle de cycle de vie ; versionnement activé ; les versions non courantes expirent après 90 jours | Beaucoup de lectures, volume énorme, aucune modification sur place. Les utilisateurs téléversent via des URL `PUT` pré-signées ; les téléchargements passent par un CDN |
| Données PostgreSQL | Volume de blocs sur l'instance de la base de données | Instantané quotidien ; copie vers une autre région chaque semaine | Besoin de faible latence et d'IOPS ; un seul écrivain |
| Modèles de configuration | Partage de fichiers | Instantané quotidien | Plusieurs serveurs d'application le montent et modifient les fichiers sur place |
| Sauvegardes | Bucket distinct dans un autre compte et une autre région | Niveau d'archive, verrouillage d'objet pendant 30 jours | Satisfait la règle 3-2-1 : survit à la suppression du compte principal |

Vérifions les chiffres. Conserver 2 TB de photos en trois réplicas exige 6 TB de disque brut (3x). Un code d'effacement 4+2 en exige 3 TB (1,5x) : pour la même protection, vous stockez moitié moins. Si l'objectif de disponibilité du magasin d'objets est de 99,9 %, prévoyez jusqu'à environ 8,8 heures par an pendant lesquelles les téléversements peuvent échouer : l'application doit réessayer et afficher un message clair, sans perdre la photo. La durabilité des photos est une autre question : la suppression d'un préfixe par un ingénieur est couverte par le versionnement, et la perte de tout le compte par la sauvegarde inter-comptes.

Chiffrement : le bucket utilise une clé gérée par le client dans le KMS, afin que l'équipe de sécurité contrôle la politique de la clé et voie chaque utilisation dans le journal d'audit ; le volume de la base de données utilise la clé par défaut gérée par le fournisseur. Tout le trafic passe en HTTPS, et le blocage de l'accès public est activé pour le compte.

## Pièges courants
- **Traiter la durabilité comme une sauvegarde** — les onze neuf protègent contre la perte matérielle, pas contre votre propre `DELETE`. Activez le versionnement et conservez une copie indépendante.
- **Public par accident** — une seule politique ou ACL large avec `Principal: "*"` expose les données. Gardez le blocage de l'accès public activé et passez les politiques en revue.
- **S'attendre à des dossiers** — dans le stockage d'objets, les « dossiers » sont des préfixes. En renommer un réécrit chaque objet placé dessous, et un dossier vide n'existe pas.
- **Versionnement sans cycle de vie** — chaque écrasement est facturé pour toujours tant qu'aucune règle ne fait expirer les versions non courantes.
- **Archiver des données que vous lisez encore** — les frais et les délais de récupération peuvent coûter plus cher que de rester dans un niveau chaud. Modélisez d'abord les schémas d'accès.
- **Monter un volume de blocs sur deux serveurs** — un système de fichiers ordinaire comme ext4 n'est pas conçu pour des écrivains concurrents et sera corrompu. Utilisez le stockage de fichiers, ou un système de fichiers de cluster.
- **Ne jamais tester les restaurations** — les sauvegardes échouent en silence. Restaurez à intervalles réguliers.
- **URL pré-signées de longue durée** — une URL valable plusieurs jours est un mot de passe dans un fichier journal. Comptez en minutes, pas en jours.

## Considérations de sécurité
- **Moindre privilège et aucun accès public.** Accordez les actions les plus restreintes sur les préfixes les plus restreints, ne mettez jamais de clés d'accès dans le code ni dans des dépôts, et utilisez si possible des identifiants de courte durée issus de rôles. Activez le blocage de l'accès public au niveau du compte.
- **Surveillance et audit.** Activez la journalisation des accès et la piste d'audit du fournisseur pour le bucket et pour l'utilisation des clés KMS. Déclenchez une alerte sur les modifications des politiques de bucket et sur tout nouvel accès public.
- **Protection contre les rançongiciels et les erreurs.** Activez le versionnement, exigez l'authentification multifacteur (MFA, multi-factor authentication) pour les suppressions définitives lorsqu'elle est proposée, utilisez le verrouillage d'objet pour les sauvegardes et gardez une copie dans un compte distinct.
- **Chiffrement partout.** Utilisez TLS pour tout le trafic et le chiffrement au repos. Pour les données sensibles, utilisez des clés gérées par le client, restreignez qui peut les utiliser ou les supprimer, et rappelez-vous que supprimer une clé détruit définitivement les données qu'elle protège (ce qu'on appelle la destruction cryptographique, crypto-shredding : utile quand il faut effacer des données, dangereuse par accident).
- **Traitez les URL pré-signées comme des secrets.** Expiration courte, un objet, une opération ; ne les journalisez pas et ne les diffusez pas largement.
- **Tenez compte du modèle de responsabilité partagée.** Le fournisseur sécurise le service ; vous êtes responsable de la configuration, des clés, des permissions et des sauvegardes. La plupart des incidents de stockage viennent d'une mauvaise configuration, pas d'une défaillance du fournisseur.
- **Suivez une norme.** NIST SP 800-209 fournit des lignes directrices de sécurité pour l'infrastructure de stockage.

## Résumé
- Le stockage en blocs est un volume brut pour une instance (faible latence, IOPS) ; le stockage de fichiers est un système de fichiers partagé (NFS ou SMB) ; le stockage d'objets conserve des objets entiers dans un bucket plat et s'atteint via HTTP, l'API S3 étant le standard de fait.
- La durabilité signifie que les données ne sont pas perdues ; la disponibilité signifie qu'elles sont accessibles. La réplication copie des objets entiers ; le codage d'effacement les découpe en fragments de données et de parité pour un surcoût moindre. Les onze neuf ne protègent pas contre la suppression.
- Les classes de stockage échangent un stockage moins cher contre des frais et des délais de récupération. Les règles de cycle de vie déplacent ou font expirer les données automatiquement. Le versionnement transforme les suppressions en marqueurs de suppression et conserve les anciennes versions.
- Partagez avec une URL pré-signée, pas en rendant le bucket public ; gardez le blocage de l'accès public activé.
- Un instantané est une copie rapide à un instant donné ; une sauvegarde est une copie indépendante qui suit la règle 3-2-1 et dont la restauration a été testée.
- Chiffrez au repos (clés gérées par le fournisseur ou par le client dans un KMS) et en transit (TLS). La propriété de la clé détermine qui contrôle l'accès aux données.

## Glossaire
| Terme | Définition |
|---|---|
| Stockage en blocs | Stockage présenté comme un volume brut de blocs de taille fixe qu'un serveur formate avec un système de fichiers. |
| Volume | Un périphérique de stockage en blocs de taille fixe, attaché à une instance. |
| Système de fichiers | La structure (comme ext4, XFS ou NTFS) qui organise les blocs en fichiers et en répertoires. |
| IOPS | Opérations d'entrée/sortie par seconde : le nombre de lectures et d'écritures qu'un volume traite. |
| Débit | Octets transférés par seconde ; IOPS multipliées par la taille de chaque opération. |
| Latence | La durée d'exécution d'une opération de stockage. |
| Stockage de fichiers | Un système de fichiers partagé servi par le réseau, avec répertoires, permissions et verrouillage. |
| Network File System (NFS) | Un protocole de montage de partages de fichiers distants, courant sous Linux et Unix (NFSv4.1 : RFC 8881). |
| Server Message Block (SMB) | Un protocole de partage de fichiers, courant sous Windows. |
| Sémantique POSIX | Le comportement des fichiers défini par la Portable Operating System Interface : mises à jour partielles, renommage atomique, permissions et verrous. |
| Stockage d'objets | Stockage d'objets entiers avec leurs métadonnées dans des buckets plats, accessible via une API HTTP. |
| Objet | Les données stockées dans un bucket, avec leur clé et leurs métadonnées. |
| Bucket | Un conteneur nommé pour des objets dans le stockage d'objets. |
| Clé | Le nom unique d'un objet au sein d'un bucket. |
| Métadonnées | Informations sur un objet : champs système (taille, type de contenu, date) et paires clé-valeur personnalisées. |
| Espace de noms plat | Un schéma de nommage sans hiérarchie de répertoires : les clés sont des chaînes uniques. |
| Préfixe | La partie initiale d'une clé, se terminant généralement par `/`, utilisée pour regrouper et lister les objets comme des dossiers. |
| Téléversement multipartie | Téléverser un gros objet en parties qui peuvent être envoyées et relancées indépendamment. |
| API S3 | L'interface HTTP d'Amazon S3, implémentée par de nombreux fournisseurs et serveurs open source. |
| Cohérence forte en lecture après écriture | Une garantie qu'après une écriture réussie, toute lecture ultérieure renvoie les nouvelles données. |
| Durabilité | La probabilité que les données stockées ne soient ni perdues ni corrompues au fil du temps. |
| Disponibilité | La fraction du temps pendant laquelle un service est joignable et répond aux requêtes. |
| Onze neuf | Un chiffre de durabilité de 99,999999999 %, généralement par objet et par an ; un objectif de conception, pas une protection contre la suppression. |
| Accord de niveau de service (SLA) | L'engagement du fournisseur, généralement sur la disponibilité, et les crédits dus s'il n'est pas tenu. |
| Zone de disponibilité | Un centre de données physiquement distinct, ou un groupe de centres, au sein d'une région cloud. |
| Réplication | Redondance obtenue en stockant plusieurs copies complètes des données. |
| Codage d'effacement | Redondance obtenue en découpant les données en k fragments de données plus m fragments de parité, k fragments quelconques suffisant à reconstruire les données. |
| Classe de stockage (niveau) | Un niveau de prix et de performance, comme chaud, accès peu fréquent ou archive. |
| Durée minimale de stockage | La durée minimale pendant laquelle un objet d'un niveau plus froid vous est facturé, même si vous le supprimez plus tôt. |
| Règle de cycle de vie | Une politique automatique qui déplace ou supprime des objets selon l'âge, le préfixe ou l'étiquette. |
| Versionnement | Une fonction de bucket qui conserve chaque version d'un objet au lieu de l'écraser. |
| Version | Un état stocké d'un objet, identifié par un identifiant de version. |
| Marqueur de suppression | Un substitut qui devient la version courante quand vous supprimez un objet versionné ; les versions plus anciennes subsistent. |
| URL pré-signée | Une URL contenant une signature et une expiration, qui accorde une opération sur un objet. |
| Politique de bucket | Une politique de ressource JSON attachée à un bucket, qui autorise ou refuse des actions à des principaux. |
| Bucket public | Un bucket dont les données peuvent être lues par n'importe qui sur Internet sans identifiants. |
| Blocage de l'accès public | Un paramètre qui l'emporte sur toute politique ou ACL qui rendrait un bucket ou ses objets publics. |
| Liste de contrôle d'accès (ACL) | Une liste de permissions plus ancienne, par objet ou par bucket ; préférez les politiques. |
| Réseau de diffusion de contenu (CDN) | Un réseau de serveurs périphériques qui met en cache et sert le contenu près des utilisateurs. |
| Instantané | Une copie à un instant donné, généralement incrémentielle, d'un volume ou d'un partage, conservée par défaut à côté de l'original. |
| Cohérent après plantage | Une copie équivalente au disque au moment d'une coupure de courant, sans vidage des écritures de l'application. |
| Sauvegarde | Une copie indépendante qui survit à la perte de l'original et de son compte, de sa région ou de son système. |
| Règle 3-2-1 | Conserver 3 copies sur 2 types de stockage, dont 1 copie hors site. |
| Verrouillage d'objet / WORM | Écrire une fois, lire plusieurs fois : empêche la modification ou la suppression d'un objet avant une date de rétention. |
| Chiffrement au repos | Chiffrer les données stockées pour que les supports ou copies volés soient illisibles. |
| Service de gestion de clés (KMS) | Un service qui crée, stocke, contrôle et audite l'utilisation des clés de chiffrement. |
| Clé gérée par le fournisseur | Une clé de chiffrement créée et contrôlée par le fournisseur de cloud. |
| Clé gérée par le client | Une clé de chiffrement que vous contrôlez dans un KMS, avec votre propre politique, rotation et piste d'audit. |
| Chiffrement d'enveloppe | Chiffrer les données avec une clé de données, puis chiffrer cette clé de données avec une clé du KMS. |
| Destruction cryptographique (crypto-shredding) | Rendre des données irrécupérables en détruisant la clé qui les chiffre. |
| Transport Layer Security (TLS) | Le protocole qui chiffre et authentifie les connexions réseau, comme HTTPS (TLS 1.3 : RFC 8446). |
| ETag | Un identifiant du contenu d'un objet renvoyé par le service, souvent une empreinte MD5 pour les téléversements simples. |
| Authentification multifacteur (MFA) | Exiger une seconde preuve d'identité en plus d'un mot de passe ou d'une clé. |

## Vérifiez vos connaissances
1. Un collègue dit : « Notre bucket offre onze neuf de durabilité, nous n'avons donc pas besoin de sauvegardes. » Expliquez deux manières dont des données peuvent tout de même être perdues.
2. Vous devez stocker 500 TB de données de recherche lues une fois par an. Comparez un niveau chaud et un niveau d'archive. Que mesureriez-vous avant de décider ?
3. Pourquoi `aws s3 rm` sur un bucket versionné ne libère-t-il aucun espace de stockage, et comment supprimeriez-vous définitivement les données ?
4. Expliquez comment une URL pré-signée permet à un navigateur de téléverser une photo directement dans un bucket privé. Qui détient les identifiants, et qu'est-ce qui limite les dégâts si l'URL fuite ?
5. Votre équipe stocke les instantanés d'un volume de base de données dans le même compte. Repensez cette organisation pour respecter la règle 3-2-1, et dites comment vous prouveriez qu'elle fonctionne.
6. Un responsable de la conformité demande qui peut lire les objets chiffrés avec des clés gérées par le fournisseur et qui peut lire ceux chiffrés avec des clés gérées par le client. Que répondez-vous ?

## Références
- [NIST SP 800-209](https://csrc.nist.gov/pubs/sp/800/209/final) — Security Guidelines for Storage Infrastructure.
- [Amazon S3 API reference](https://docs.aws.amazon.com/AmazonS3/latest/API/Welcome.html) — l'API de stockage d'objets de facto.
- [Amazon S3 User Guide: versioning, lifecycle, presigned URLs, Block Public Access](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) — la documentation d'un fournisseur sur ces fonctions.
- [RFC 8881](https://www.rfc-editor.org/rfc/rfc8881) — Network File System (NFS) Version 4 Minor Version 1 Protocol.
- [RFC 8446](https://www.rfc-editor.org/rfc/rfc8446) — The Transport Layer Security (TLS) Protocol Version 1.3.
- [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110) — HTTP Semantics.
- [NIST SP 800-57 Part 1](https://csrc.nist.gov/pubs/sp/800/57/pt1/r5/final) — Recommendation for Key Management.
- [SNIA Dictionary](https://www.snia.org/education/dictionary) — terminologie du stockage.
