Les trois premières parties de cette série ont regardé des moteurs qui modifient des pages de taille fixe sur place, ou à côté de leurs anciennes versions. Apache Cassandra prend une autre route : il ne modifie jamais un fichier. Chaque écriture finit dans une SSTable Cassandra, un fichier trié, écrit une fois et jamais changé. Cette partie bonus (5/3+2 dans la numérotation de la série, après SQLite) ouvre un vrai nœud pour montrer ce que cela donne sur le disque.
Je ne fais pas tourner Cassandra chez moi. Tout ce qui suit vient d’un laboratoire à un nœud monté pour ce billet (Rocky Linux 10.2 sous WSL2, Apache Cassandra 5.0.9, Java 17.0.21 de Temurin) et de la documentation d’Apache. Les sorties sont réelles : je coupe seulement des lignes, et je marque chaque coupure par [...]. Avec un seul nœud, il n’y a ni réplication, ni réparation, ni streaming : je dis quand cela compte.
Le répertoire de données de Cassandra

Un nœud range ses fichiers dans quatre répertoires. Leur emplacement vient de cassandra.yaml, et l’installation par archive les place sous data/.
commitlog/: le journal des commits, découpé en segments de 32 Mio, la valeur par défaut documentée. Un nœud neuf en avait déjà deux, de 33 554 432 octets chacun.data/: les SSTables. L’arborescence estdata/<keyspace>/<table>-<identifiant de table>/. Ma table s’est retrouvée dansdemo/readings-b5b8f990…. Les keyspaces système (system,system_schema…) sont à côté et utilisent le même format.hints/: l’endroit où les écritures attendent un nœud en panne. La référence le relie àmax_hint_window, la durée pendant laquelle un hôte mort reçoit des hints. Il est resté vide.saved_caches/: les caches de clés, de lignes et de compteurs, sauvegardés pour qu’un redémarrage ne reparte pas à froid. Vide aussi.
Dans les parties précédentes, une base de données était un répertoire. Ici, un keyspace est un répertoire, et chaque table est un répertoire à l’intérieur, avec un long suffixe qui identifie la table.
Le chemin d’écriture : journal des commits, memtable, flush

Une écriture va à deux endroits. D’abord le journal des commits : Cassandra ajoute le changement à un segment sur disque, pour qu’il survive à un crash. Ensuite la memtable, une structure triée en mémoire, en général une par table. Par défaut, le journal est synchronisé toutes les 10 secondes (commitlog_sync: periodic, commitlog_sync_period: 10000ms), donc une écriture est acquittée avant d’être sur le disque. L’alternative, batch, attend la synchronisation.
Dans le labo, j’ai inséré sept lignes dans une table neuve et j’ai regardé avant le flush. Le répertoire de la table était vide. Sept cellules étaient dans la memtable, et le journal des commits tenait leur seule copie sur disque :
SSTable count: 0
Old SSTable count: 0
Memtable cell count: 7
Memtable data size: 367
Memtable switch count: 0
Le journal des commits n’est pas compressé tant qu’on ne le demande pas, donc les clés sont lisibles dans un segment. J’ai regardé avec strings :
strings CommitLog-7-*.log | grep -E "sensor-[abc]" | head -5
sensor-a
sensor-a
sensor-a
sensor-b
sensor-b
Un flush transforme la memtable en SSTable. Chaque SSTable Cassandra naît d’un flush. Il se déclenche quand la mémoire manque, quand le journal approche de sa limite, ou à la demande. J’ai lancé nodetool flush demo readings et huit fichiers sont apparus :
ls -l | awk '{print $5, $9}'
47 nb-1-big-CompressionInfo.db
123 nb-1-big-Data.db
10 nb-1-big-Digest.crc32
16 nb-1-big-Filter.db
36 nb-1-big-Index.db
4855 nb-1-big-Statistics.db
68 nb-1-big-Summary.db
92 nb-1-big-TOC.txt
Après le flush, les deux segments du journal étaient toujours là. La documentation dit qu’un segment ne peut être supprimé ou recyclé qu’une fois toutes ses données écrites dans des SSTables, et les segments sont partagés entre toutes les tables : je n’en ai donc vu aucun disparaître.
Anatomie d’une SSTable Cassandra

Une SSTable Cassandra est un ensemble de fichiers qui partagent un préfixe. Dans le labo, nb-1-big- se lit comme une version de format (nb), un numéro de génération et le nom du format (big, celui par défaut). La documentation n’explicite pas ce motif : c’est ma lecture des noms. Elle décrit aussi un format à base de trie dont l’index vit dans Partitions.db et Rows.db à la place de Index.db ; je ne l’ai pas testé. Le fichier TOC.txt liste les composants :
cat nb-1-big-TOC.txt
CompressionInfo.db
Data.db
Digest.crc32
Filter.db
Index.db
Statistics.db
Summary.db
TOC.txt
Data.db(123 octets) : les lignes, groupées par partition et compressées par blocs. Le compresseur par défaut est LZ4, et le taux de compression était de 0,68.Index.db(36 octets) : les clés de partition et leurs positions dansData.db.Summary.db(68 octets) : un échantillon de l’index, une entrée sur 128 par défaut.Filter.db(16 octets) : le filtre de Bloom des clés de partition.CompressionInfo.db(47 octets) : les positions et les tailles des blocs compressés.Statistics.db(4 855 octets) : des métadonnées comme les horodatages, les tombstones et les TTL. C’est le plus gros fichier ici, etsstablemetadataen tire des histogrammes.Digest.crc32(10 octets) : une empreinte CRC-32 deData.db.
Une lecture ne parcourt pas ces fichiers. Pour une clé de partition, Cassandra interroge d’abord le filtre de Bloom. Une réponse négative est définitive, alors qu’une réponse positive peut être fausse (la probabilité de faux positif de la table était de 0,01). Ensuite il réduit la recherche avec le résumé, trouve la position exacte dans l’index, et décompresse le bloc. Après deux flushs, nodetool getsstables indique quels fichiers peuvent contenir une clé :
nodetool getsstables demo readings sensor-a
data/data/demo/readings-b5b8f990d6fb11f197b7370581990151/nb-1-big-Data.db
data/data/demo/readings-b5b8f990d6fb11f197b7370581990151/nb-2-big-Data.db
Partitions, lignes et cellules dans Data.db

Dans Data.db, les lignes sont groupées par partition. Les partitions se suivent dans l’ordre des tokens, le hachage de la clé de partition, et les lignes d’une partition suivent la clé de clustering. C’est pourquoi mes trois capteurs ne sont pas dans l’ordre alphabétique : sensor-b vient d’abord, puis sensor-c, puis sensor-a. sstabledump affiche une partition ainsi :
sstabledump nb-1-big-Data.db
[
{
"partition" : {
"key" : [ "sensor-b" ],
"position" : 22
},
"rows" : [
{
"type" : "row",
"position" : 22,
"clustering" : [ 1 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:26:44.439221Z" },
"cells" : [
{ "name" : "temp", "value" : 15 }
]
},
{
"type" : "row",
"position" : 37,
"clustering" : [ 2 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:26:44.441834Z" },
"cells" : [
{ "name" : "temp", "value" : 16 }
]
}
]
},
[...]
]
Chaque ligne porte l’horodatage de son INSERT dans liveness_info, et chaque cellule peut porter le sien. L’outil de métadonnées confirme l’ordre des tokens, la compression et l’absence de tombstones :
sstablemetadata nb-1-big-Data.db
Partitioner: org.apache.cassandra.dht.Murmur3Partitioner
Bloom Filter FP chance: 0.01
Compressor: org.apache.cassandra.io.compress.LZ4Compressor
Compression ratio: 0.68
First token: -2257014703785893100 (sensor-b)
Last token: 6459236691210746121 (sensor-a)
Covered clusterings: [1, 3]
Estimated droppable tombstones: 0.0
totalRows: 7
Le fichier d’index est assez petit pour se lire à la main :
xxd nb-1-big-Index.db
00000000: 0008 7365 6e73 6f72 2d62 0000 0008 7365 ..sensor-b....se
00000010: 6e73 6f72 2d63 3500 0008 7365 6e73 6f72 nsor-c5...sensor
00000020: 2d61 6c00 -al.
Chaque entrée est une longueur sur deux octets (0008), la clé, une position et un zéro. Les positions sont 00, 35 et 6c : 0, 53 et 108 dans le flux de données non compressé. sstabledump indique 22, 75 et 130 pour la première ligne de chaque partition, soit 22 octets après chaque début. Cela correspond à un en-tête fait d’une longueur de clé sur deux octets, de la clé sur huit octets et d’une date de suppression sur douze octets. La documentation ne décrit pas la disposition des octets de Data.db : prenez ce décodage pour ma lecture de la sortie, pas pour une spécification.
Un UPDATE ou un DELETE est une nouvelle écriture
Rien dans une SSTable Cassandra n’est jamais modifié. Pour le voir, j’ai changé une valeur, ajouté une ligne, supprimé une ligne, supprimé une partition entière, puis refait un flush :
UPDATE demo.readings SET temp = 25 WHERE device='sensor-a' AND ts=2;
INSERT INTO demo.readings (device, ts, temp) VALUES ('sensor-a', 4, 23);
DELETE FROM demo.readings WHERE device='sensor-b' AND ts=2;
DELETE FROM demo.readings WHERE device='sensor-c';
La deuxième SSTable, nb-2, ne contient que ces changements. La mise à jour est une cellule avec son propre horodatage, et les suppressions sont des tombstones, un pour une ligne et un pour une partition entière :
sstabledump nb-2-big-Data.db
[
{
"partition" : {
"key" : [ "sensor-b" ],
"position" : 22
},
"rows" : [
{
"type" : "row",
"position" : 22,
"clustering" : [ 2 ],
"deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.783855Z", "local_delete_time" : "2026-11-02T20:27:29Z" },
"cells" : [ ]
}
]
},
{
"partition" : {
"key" : [ "sensor-c" ],
"position" : 57,
"deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.787731Z", "local_delete_time" : "2026-11-02T20:27:29Z" }
},
"rows" : [ ]
},
{
"partition" : {
"key" : [ "sensor-a" ],
"position" : 80
},
"rows" : [
{
"type" : "row",
"position" : 80,
"clustering" : [ 2 ],
"cells" : [
{ "name" : "temp", "value" : 25, "tstamp" : "2026-11-02T20:27:29.773920Z" }
]
},
{
"type" : "row",
"position" : 94,
"clustering" : [ 4 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:27:29.779577Z" },
"cells" : [
{ "name" : "temp", "value" : 23 }
]
}
]
}
]
Les anciennes valeurs, 21 et 16 et les lignes de sensor-c, sont toujours dans nb-1, intactes. Une lecture fusionne les deux fichiers et garde la réponse la plus récente : le SELECT a renvoyé cinq lignes avec temp = 25. La documentation le dit simplement : Cassandra traite une suppression comme une insertion.
Le compactage réécrit les fichiers
Laissées à elles-mêmes, les SSTables s’accumulent et chaque lecture doit en regarder davantage. Le compactage les fusionne en une SSTable Cassandra neuve et abandonne ce qui est périmé. Dans le labo, j’ai désactivé le compactage automatique de la table pour le lancer à la main :
nodetool compact demo readings
141 nb-3-big-Data.db
nodetool compactionhistory
Compaction History:
id keyspace_name columnfamily_name compacted_at bytes_in bytes_out rows_merged compaction_properties
f61913d0-d6fb-11f1-97b7-370581990151 demo readings 2026-11-02T21:28:28.031 213 132 {2:3} {compaction_type:Major compaction}
Deux SSTables de 123 et 90 octets sont devenues une seule de 141 octets. Dans l’historique, rows_merged {2:3} devrait vouloir dire que trois partitions étaient présentes dans deux SSTables chacune (ma lecture). L’historique annonce 132 octets écrits alors que le fichier Data.db en fait 141 ; je n’ai pas creusé cet écart. Le fichier fusionné a gardé la mise à jour (25 a remplacé 21) et abandonné les valeurs couvertes par des tombstones, mais les tombstones eux-mêmes sont toujours là :
sstabledump nb-3-big-Data.db
[
{
"partition" : {
"key" : [ "sensor-b" ],
"position" : 22
},
"rows" : [
{
"type" : "row",
"position" : 22,
"clustering" : [ 1 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:26:44.439221Z" },
"cells" : [
{ "name" : "temp", "value" : 15 }
]
},
{
"type" : "row",
"position" : 37,
"clustering" : [ 2 ],
"deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.783855Z", "local_delete_time" : "2026-11-02T20:27:29Z" },
"cells" : [ ]
}
]
},
{
"partition" : {
"key" : [ "sensor-c" ],
"position" : 74,
"deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.787731Z", "local_delete_time" : "2026-11-02T20:27:29Z" }
},
"rows" : [ ]
},
{
"partition" : {
"key" : [ "sensor-a" ],
"position" : 97
},
"rows" : [
{
"type" : "row",
"position" : 97,
"clustering" : [ 1 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:26:44.426582Z" },
"cells" : [
{ "name" : "temp", "value" : 20 }
]
},
{
"type" : "row",
"position" : 111,
"clustering" : [ 2 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:26:44.432537Z" },
"cells" : [
{ "name" : "temp", "value" : 25, "tstamp" : "2026-11-02T20:27:29.773920Z" }
]
},
{
"type" : "row",
"position" : 130,
"clustering" : [ 3 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:26:44.435827Z" },
"cells" : [
{ "name" : "temp", "value" : 22 }
]
},
{
"type" : "row",
"position" : 145,
"clustering" : [ 4 ],
"liveness_info" : { "tstamp" : "2026-11-02T20:27:29.779577Z" },
"cells" : [
{ "name" : "temp", "value" : 23 }
]
}
]
}
]
La stratégie par défaut est celle par paliers de taille (STCS), celle qu’utilisait la table. La documentation décrit aussi les compactages par niveaux (LCS), par fenêtres de temps (TWCS) et unifié (UCS), et recommande UCS pour les nouvelles charges. Je n’ai lancé que STCS.
Pourquoi les fichiers ne rétrécissent pas tout de suite

Un tombstone doit survivre aux données qu’il couvre, pour que chaque réplica apprenne la suppression. C’est le rôle de gc_grace_seconds, dix jours par défaut. La documentation ajoute qu’un tombstone n’est retiré que par un compactage après ce délai, et seulement si toutes les SSTables qui contiennent des données plus anciennes participent au même compactage.
Pour voir l’effet sur la taille, j’ai chargé 60 000 lignes dans une seconde table (100 partitions de 600 lignes), supprimé 90 partitions, et mesuré les fichiers Data.db à chaque étape :
| Étape | Octets de Data.db | SSTables |
|---|---|---|
| Chargé et vidé sur disque | 6 206 495 | 1 |
| Après suppression de 90 partitions et flush | 6 207 388 | 2 |
| Après nodetool compact | 621 829 | 1 |
| Après gc_grace_seconds = 0 et garbagecollect | 620 584 | 1 |
La suppression a fait grossir le répertoire, de 6 221 956 à 6 229 063 octets, parce que les tombstones sont des données neuves. Seul le compactage a rendu la place, et les données sont passées d’environ 6,2 Mo à 0,62 Mo. La dernière étape a retiré 1 245 octets de plus, ce qui correspond aux 90 tombstones de partition. Je l’ai fait dans le labo ainsi :
ALTER TABLE demo.bulk WITH gc_grace_seconds = 0;
nodetool garbagecollect demo bulk
Ne copiez pas cela sur un vrai cluster. Si un réplica était en panne pendant que le tombstone existait, et que le tombstone est purgé avant son retour, les données supprimées peuvent réapparaître. La documentation appelle cela des zombies. Sur un seul nœud, il n’y a pas de risque.
Un détail sur les outils : sstablemetadata estime les tombstones supprimables avec un délai de grâce nul, sauf si vous passez --gc_grace_seconds. Il a affiché 0,0136 par défaut, et 0,0 avec 864000, le vrai réglage de la table.
Cassandra à côté des trois moteurs
| InnoDB | PostgreSQL | Oracle | Cassandra | |
|---|---|---|---|---|
| Unité sur disque | page de 16 Ko | page de 8 Ko | bloc de 8 Ko par défaut | une SSTable Cassandra immuable |
| UPDATE | sur place, ancienne version dans l’undo | une nouvelle version de tuple dans la table | sur place, image avant dans l’undo | une nouvelle cellule avec un horodatage plus récent, dans une nouvelle SSTable |
| DELETE | enregistrement marqué, purgé plus tard | tuple laissé en place jusqu’au VACUUM | ligne retirée dans le bloc, la marque haute reste | un tombstone, une nouvelle écriture |
| La place revient avec | une reconstruction de table | VACUUM | SHRINK SPACE ou MOVE | le compactage, après gc_grace_seconds |
Aucun de ces choix n’est meilleur dans l’absolu. Cassandra paie des écritures rapides et séquentielles avec du travail en arrière-plan : chaque mise à jour laisse une ancienne version derrière elle, et le compactage doit nettoyer plus tard. Quand on le sait, un répertoire de données qui grossit après une grosse suppression ne surprend plus.
Ce billet fait partie d’une série de notes d’administration système (tag « carnet d’admin »).
Série « Dans les fichiers d’une base de données », partie 5/3+2 (bonus). · Partie 3/3 et la comparaison · English version
Sources
- Documentation d’Apache Cassandra 5.0 : moteur de stockage (journal des commits, memtable, composants d’une SSTable), vue d’ensemble du compactage (stratégies, tombstones,
gc_grace_seconds) et la référence decassandra.yaml. - Le labo : Rocky Linux 10.2, Apache Cassandra 5.0.9, Java 17.0.21 de Temurin, WSL2, un seul nœud. Testé sur un seul nœud.
Laisser un commentaire