Sur ce bucket de test, on vient de supprimer un fichier de 10 Mio écrit cinq fois. Voici ce qu'il liste :
$ aws s3 ls --summarize --recursive s3://demo
Total Objects: 0
Total Size: 0
Zéro objet, zéro octet, et rien n'a quitté le disque.
Un bucket S3 versionné ne rétrécit pas après une suppression parce qu'un DELETE sans identifiant de version ne détruit aucune donnée : il pose un marqueur de suppression, qui masque l'objet dans les listes, pendant que toutes ses versions restent stockées et facturées. Pour récupérer l'espace, il faut une règle de cycle de vie NoncurrentVersionExpiration, qui efface les versions non courantes, puis ExpiredObjectDeleteMarker, qui retire les marqueurs restés seuls.
Le même mécanisme sert à restaurer un objet supprimé, sauf si la version non courante a déjà expiré, si une suppression a visé chaque version par son identifiant, ou si le versionnage était suspendu et que le marqueur a remplacé la version null.
1. Monter le banc MinIO et AWS CLI
Le banc du 2 novembre 2026 : AWS CLI 2.39.3 contre MinIO RELEASE.2026-10-23T20-06-51Z, dans deux conteneurs. Toutes les sorties de l'article en viennent. Une seule étape n'a pas pu s'y dérouler, la purge par âge : la section 4 dit pourquoi.
Le dépôt GitHub de MinIO est archivé, son README annonce la fin de maintenance. Le jour du test, docker pull minio/minio échouait (pull access denied) et dl.min.io répondait 410. On a pris la reconstruction publiée par Chainguard, un fork : les résultats valent pour cette version.
docker network create s3-test
docker run -d --rm --name s3 --network s3-test --tmpfs /data:rw,uid=65532,size=2g \
-e MINIO_ROOT_USER=admin -e MINIO_ROOT_PASSWORD=adminadmin123 \
-e MINIO_SCANNER_SPEED=fastest cgr.dev/chainguard/minio server /data
MINIO_SCANNER_SPEED=fastest pousse au plus rapide le scanner qui applique les règles. Réglage de banc : les délais observés ici ne disent rien de la production. Le client, dans le même réseau, sans pager :
docker run -it --rm --name s3-cli --network s3-test \
-e AWS_ACCESS_KEY_ID=admin -e AWS_SECRET_ACCESS_KEY=adminadmin123 \
-e AWS_DEFAULT_REGION=us-east-1 -e AWS_ENDPOINT_URL=http://s3:9000 \
-e AWS_PAGER= --entrypoint bash amazon/aws-cli
Dans ce shell, on active le versionnage, on écrit cinq fois la même clé et on la supprime.
aws s3api create-bucket --bucket demo
aws s3api put-bucket-versioning --bucket demo \
--versioning-configuration Status=Enabled
dd if=/dev/urandom of=/tmp/10m bs=1M count=10
for i in 1 2 3 4 5; do aws s3 cp /tmp/10m s3://demo/dump.sql.gz --quiet; done
aws s3 rm s3://demo/dump.sql.gz
2. Mesurer ce que le bucket stocke vraiment
s3 ls et ListObjectsV2 ne montrent que les objets dont la version courante n'est pas un marqueur. Pour voir le reste, il faut ListObjectVersions, avec la permission s3:ListBucketVersions.
$ aws s3api list-object-versions --bucket demo
{
"Versions": [
{
"Size": 10485760,
"Key": "dump.sql.gz",
"VersionId": "90524f5b-95ba-4fb4-82db-25032e8ae951",
"IsLatest": false,
"LastModified": "2026-11-02T19:17:09.449000+00:00",
Sortie coupée à la première des cinq versions, champs ETag, StorageClass et Owner retirés. Le bucket que s3 ls dit vide garde tout, en IsLatest: false. Pour sommer :
$ aws s3api list-object-versions --bucket demo \
--query '{versions:length(Versions || `[]`),octets:sum((Versions || `[]`)[].Size),marqueurs:length(DeleteMarkers || `[]`)}'
{
"versions": 5,
"octets": 52428800,
"marqueurs": 1
}
Sur un bucket jumeau, le client MinIO compte 50 Mio pour 5 versions avec mc du --versions, et 0 octet pour 0 objet avec mc du.
Sur un gros bucket, passez par S3 Inventory ou Storage Lens.
3. Ce qui occupe la place après une suppression
Les versions non courantes d'abord. Chaque version compte pour un objet entier, sans différentiel : AWS facture trois objets pour trois versions.
Viennent les marqueurs : leur taille est celle du nom de la clé, les purger ne libère donc pas d'espace. En excès, ils peuvent dégrader les performances du bucket selon AWS, et ils comptent comme objets.
Une règle Expiration seule aggrave le compte. Sur un bucket versionné, elle ne supprime rien et ajoute des marqueurs : chez AWS, 100 objets en deviennent 200.
Restent les téléversements multipart inachevés, hors d'atteinte des règles d'expiration. Sur le banc, avec une part de 10 Mio en attente, seul list-multipart-uploads voit gros.bin. Il leur faut AbortIncompleteMultipartUpload.
Suspendre le versionnage ne rend rien non plus. Un DELETE remplace la version null par un marqueur, ce qui détruit sa donnée. Testé : la version null a disparu, celle écrite avant la suspension est restée.
Un restic forget --prune sur un dépôt S3 subit le même sort : sur un bucket versionné, ses suppressions deviennent des marqueurs, et la facture ne bouge pas sans règle de purge.
4. Purger versions et marqueurs par cycle de vie
Avant d'écrire la règle, fixez combien de temps vous voulez pouvoir revenir en arrière. Le fichier /tmp/lc.json :
{
"Rules": [
{
"ID": "purge-versions",
"Status": "Enabled",
"Filter": { "Prefix": "" },
"NoncurrentVersionExpiration": { "NoncurrentDays": 30 }
},
{
"ID": "purge-marqueurs",
"Status": "Enabled",
"Filter": { "Prefix": "" },
"Expiration": { "ExpiredObjectDeleteMarker": true }
}
]
}
aws s3api put-bucket-lifecycle-configuration --bucket demo \
--lifecycle-configuration file:///tmp/lc.json
MinIO l'accepte et le GET rend les deux règles. Sur AWS, ajoutez AbortIncompleteMultipartUpload. Ce MinIO la refuse seule dans sa règle et, dans celle des versions, le GET ne la rend pas. Reste abort-multipart-upload, à la main.
Les trente jours viennent d'un exemple AWS, aucune norme ne les impose. Ils fixent aussi la fenêtre de restauration : passé ce délai, la version est détruite. Dès la pose, toute version non courante depuis plus de trente jours devient éligible. Contre une compromission du compte, il faut Object Lock. Pour les classes froides, voir les règles de cycle de vie et l'archivage.
Le PUT remplace toute la configuration : lisez l'existant, fusionnez, puis écrivez. Sur AWS, retirez TransitionDefaultMinimumObjectSize de la sortie du GET, sinon le PUT échoue. ExpiredObjectDeleteMarker ne se combine pas avec Days, MinIO le refuse aussi.
Pas de raccourci à zéro jour. MinIO répond ceci à NoncurrentDays: 0, malgré le mot Expiration du message :
aws: [ERROR]: An error occurred (InvalidArgument) when calling the PutBucketLifecycleConfiguration operation: Days must be positive integer when used with Expiration
Côté AWS, NoncurrentDays doit aussi être un entier positif, et l'échéance est arrondie au minuit UTC suivant. La purge par âge ne peut donc pas se déclencher sur un banc de moins d'un jour. Sur un bucket jumeau, une règle à NoncurrentDays: 1 n'avait rien emporté après 420 secondes : toujours 5 versions, 52 428 800 octets et le marqueur. L'effet des trente jours n'a donc pas été observé.
Pour voir la purge tourner, on a remplacé la règle sur demo par une règle au nombre de versions, sans âge :
{ "NoncurrentVersionExpiration": { "NewerNoncurrentVersions": 1 } }
$ aws s3api list-object-versions --bucket demo \
--query '{v:length(Versions),d:length(DeleteMarkers)}'
{
"v": 1,
"d": 1
}
Il ne restait que la version la plus récente et le marqueur, 5 secondes après la pose, scanner au plus vite. Ne posez pas cette règle hors d'un banc. Sur AWS, ce nombre ne purge qu'une fois l'âge franchi aussi ; non testé.
Le marqueur reste tant qu'une version le suit : sa règle ne l'a pas touché en 420 secondes sur le bucket jumeau. Seul, il part : rien en 60 secondes sans règle, disparu 6 secondes après la pose de ExpiredObjectDeleteMarker.
Une purge peut tarder sans être cassée. Sur AWS, les objets éligibles peuvent partir « des jours, voire des semaines » plus tard, mais la facturation s'arrête dès l'éligibilité. Sur MinIO, le disque reste plein tant que le scanner, en basse priorité, n'est pas passé. Avec un volume déjà saturé, n'y comptez pas.
AWS ne purge rien non plus sous Object Lock ni en réplication Pending ou Failed.
5. Restaurer un objet en retirant son marqueur
Avant de purger quoi que ce soit, vérifiez que personne n'attend une restauration. Sur demo, on retire d'abord la règle de test avec delete-bucket-lifecycle. On supprime le marqueur, jamais une version de données.
$ aws s3api list-object-versions --bucket demo --prefix dump.sql.gz \
--query "DeleteMarkers[?IsLatest && Key=='dump.sql.gz'].VersionId" --output text
b4794390-8e6b-4adb-ba77-8cc4d6e4b86e
On attend un seul identifiant. Sans marqueur, la commande rend None, à ne jamais passer à la suite. Et --output text applique le filtre page par page : avec --page-size 1, on a obtenu l'identifiant puis trois None. Sur toute autre sortie, on s'arrête. Cet identifiant dans $MARQUEUR, le retrait est définitif :
$ aws s3api delete-object --bucket demo --key dump.sql.gz --version-id "$MARQUEUR"
{
"DeleteMarker": true,
"VersionId": "b4794390-8e6b-4adb-ba77-8cc4d6e4b86e"
}
s3 ls repasse à 1 objet et 10 485 760 octets.
Si une règle NoncurrentVersionExpiration est active, AWS recommande plutôt de copier l'ancienne version : le cycle de vie peut emporter la version voulue pendant que le retrait se propage. copy-object s'arrête à 5 Go. Rejoué après une nouvelle écriture et une nouvelle suppression :
VERSION=$(aws s3api list-object-versions --bucket demo --prefix dump.sql.gz \
--query "Versions[?Key=='dump.sql.gz']|[0].VersionId" --output text)
aws s3api copy-object --bucket demo --key dump.sql.gz \
--copy-source "demo/dump.sql.gz?versionId=$VERSION"
L'objet revient et l'historique reste : 3 versions, 1 marqueur, 31 457 280 octets. La copie coûte 10 Mio de plus.
6. Ne pas relancer le script sur un NotFound
Sur une application que nous exploitons sur MinIO, six fichiers supprimés par une tâche applicative ont été restaurés en retirant leurs marqueurs. Au premier retrait, un HeadObject a répondu NotFound juste après une suppression pourtant réussie. Observation unique, sur MinIO, cause non établie. Sur le banc, dix retraits suivis d'un HeadObject immédiat n'en ont donné aucun. Nous n'en tirons ni qu'un tel NotFound est transitoire, ni qu'il se reproduit sur AWS S3.
Le danger vient du script qui, à ce moment-là, conclut à un échec et recommence. Sans identifiant de version, son DELETE ne retire rien. Sur AWS, il empile un marqueur de plus, selon la documentation. Pas sur ce MinIO : trois suppressions de suite n'ont laissé qu'un marqueur, sous le même identifiant.
Avec un identifiant repris de la mauvaise ligne, il détruit la donnée : une suppression avec VersionId est définitive, sans confirmation. Testé sur un objet à une version : il reste 0 version et 1 marqueur, et retirer ce marqueur ne rend rien.
Un NotFound qui persiste ne prouve pas non plus l'échec. Deux marqueurs peuvent se suivre, même sur MinIO : écrire, supprimer, écrire, supprimer, puis détruire la version intermédiaire. Retirer celui du dessus laisse l'autre courant, retirer celui du dessous ne change rien. Les deux retraits réussissent, et HeadObject répond 404 quand même.
La parade tient en une relecture avant tout nouveau geste. Ici, après le retrait du marqueur du dessus :
$ CLE=a.txt
$ aws s3api list-object-versions --bucket pile2 --prefix "$CLE" \
--query "{courant:Versions[?IsLatest && Key=='$CLE'].VersionId,marqueur:DeleteMarkers[?IsLatest && Key=='$CLE'].VersionId}"
{
"courant": [],
"marqueur": [
"981c56f8-9dec-4395-8f9c-f74de380fc06"
]
}
courant rempli : le retrait a fonctionné, rien à refaire. marqueur rempli : on reprend avec cet identifiant et lui seul ; ici, ce second retrait a rendu l'objet. courant à null à côté d'un marqueur : plus aucune version sous ce préfixe, le retrait ne rendra rien. Les deux à null : on arrête et on regarde la liste entière.
Le script doit aussi vérifier qu'un identifiant figure dans DeleteMarkers avant de le supprimer. La réponse arrive trop tard : la CLI rend DeleteMarker: true pour un marqueur, le seul VersionId pour une donnée déjà détruite.
7. Ce que le compte applicatif ne voit pas
Sur le même incident, le compte applicatif pouvait retirer les marqueurs, mais GetBucketVersioning lui était refusé.
Sur AWS, la permission qui retire un marqueur est celle qui détruit une version de données : s3:DeleteObjectVersion ne distingue pas les deux. Donner ce droit à une application pour qu'elle restaure, c'est lui donner la purge. Le banc le confirme : avec un compte limité aux listes, à la lecture et aux suppressions, GetBucketVersioning répond AccessDenied, le retrait du marqueur passe, la destruction d'une version aussi.
La fenêtre de restauration exige s3:GetLifecycleConfiguration, et AWS réserve GetBucketVersioning au propriétaire du bucket. Vérifiez la règle NoncurrentVersionExpiration et l'état du versionnage avec un compte d'administration avant d'annoncer quoi que ce soit.
Le versionnage ne remplace pas non plus une copie ailleurs : les versions vivent dans le même bucket, sous le même compte et les mêmes droits. Dans une stratégie 3-2-1, il protège au mieux de l'erreur.
Sources
- AWS, Working with delete markers : taille et coût du marqueur, réponses 404 et 405
- AWS, Managing delete markers : retrait par identifiant, marqueur empilé
- AWS, Examples of S3 Lifecycle configurations : règles de purge, incompatibilité avec
Days - AWS, Lifecycle configuration elements : âge non courant, copie pour restaurer
- AWS, Setting an S3 Lifecycle configuration : délai, facturation, GET réinjecté
- AWS, Troubleshooting Amazon S3 Lifecycle issues : objets en hausse, Storage Lens, cas sans action
- AWS, Troubleshooting versioning : dégradation avec trop de marqueurs
- AWS, How S3 Versioning works : version facturée en entier
- AWS, Deleting objects from versioning-suspended buckets : perte de la version
null - AWS, API DeleteObject : permissions de suppression
- AWS, Restoring previous versions :
copy-objectavecversionId - AWS, API ListObjectVersions : permission
- MinIO, Object Lifecycle Management : scanner en basse priorité
- Dépôt GitHub minio/minio : dépôt archivé, fin de maintenance


