Aller au contenu
  • Accueil
  • Infrastructure
  • Datacenter
  • Services
    Nos services
    InfogéranceCloudHébergementIABare MetalHousingTransit IP
  • Blog
Contactez-nous
  1. Accueil
  2. /
  3. Blog
  4. /
  5. Marqueur de suppression S3 : purger un bucket qui ne rétrécit pas

Stockage
Sauvegarde
Cloud

Marqueur de suppression S3 : purger un bucket qui ne rétrécit pas

16 novembre 2026

11 min de lecture

Sommaire
1. Monter le banc MinIO et AWS CLI
2. Mesurer ce que le bucket stocke vraiment
3. Ce qui occupe la place après une suppression
4. Purger versions et marqueurs par cycle de vie
5. Restaurer un objet en retirant son marqueur
6. Ne pas relancer le script sur un NotFound
7. Ce que le compte applicatif ne voit pas
Sources

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-object avec versionId
  • 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

Besoin d'aide sur ce sujet ?

Notre équipe d'experts est là pour vous accompagner dans vos projets d'infrastructure et d'infogérance.

Contactez-nous

Articles similaires

Kopia vs Restic en 2026 : choisir son outil de sauvegarde dédupliqué
Sauvegarde
Stockage
Administration
Sauvegarde
Stockage
Administration

Kopia vs Restic en 2026 : choisir son outil de sauvegarde dédupliqué

Comparatif technique Kopia et Restic. Performance, déduplication, parallélisme, UI, retention, intégration cloud, recommandations selon le profil ops.

24 mai 2026
Lire plus
Garage : un object store S3 conçu pour la géo-réplication
Stockage
Infrastructure
Cloud
Stockage
Infrastructure
Cloud

Garage : un object store S3 conçu pour la géo-réplication

Garage est un stockage objet S3-compatible distribué, leaderless, optimisé pour la réplication multi-datacenter. Architecture Dynamo + CRDT, déploiement, comparaison avec MinIO, limites S3.

9 mai 2026
Lire plus
Stockage objet S3 : lifecycle policies et stratégies d'archivage
Stockage
Cloud
Infrastructure
Stockage
Cloud
Infrastructure

Stockage objet S3 : lifecycle policies et stratégies d'archivage

Maîtrisez les lifecycle policies S3 pour automatiser l'archivage, optimiser les coûts de stockage et garantir la conformité RGPD de vos données.

26 févr. 2026
Lire plus

SHPV, votre partenaire de confiance en infrastructure et infogérance informatique en France.

SHPV
Contactez-nousNous contacterBlog
Expertise
InfrastructureDatacenterInfogéranceCloudHébergementTransit IPIABare MetalHousing
Légales
Conditions Générales de VenteCPS - Contrat de ServicesCPS - Hébergement CloudCPS - Microsoft 365Accord sous-traitance RGPDTarifs interventions

SHPV © 2026 - Tous droits réservés

Mentions légalesPolitiques de confidentialité
SHPV FRANCE - SAS au capital de 16 000 € - 52 Rue Romain Rolland, 71230 Saint-Vallier - SIRET n°80886287400035 - R.C.S. Chalon-sur-Saône. Par téléphone 09 72 310 818 - Email: support@shpv.fr