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

Répertoires de données de Cassandra : commitlog, data, hints et saved_caches, avec les huit fichiers d’une SSTable
Les répertoires d’un nœud Cassandra et les fichiers d’une SSTable.

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 est data/<keyspace>/<table>-<identifiant de table>/. Ma table s’est retrouvée dans demo/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

Chemin d’écriture de Cassandra : journal des commits et memtable, flush vers des SSTables immuables, puis compactage
Une écriture va au journal et à la memtable ; les flushs créent des SSTables.

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

Les huit composants d’une SSTable Cassandra et l’ordre dans lequel une lecture les utilise
Tailles des composants dans le labo, et les quatre étapes d’une lecture.

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 dans Data.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, et sstablemetadata en tire des histogrammes.
  • Digest.crc32 (10 octets) : une empreinte CRC-32 de Data.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 une SSTable Cassandra : positions de Index.db et disposition des partitions, lignes et cellules de Data.db
Index.db et Data.db lus avec hexdump et sstabledump.

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

Tailles d’une SSTable Cassandra après un chargement en volume, des suppressions, un compactage et la purge des tombstones
Octets de Data.db à chaque étape, et les SSTables du petit test.

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 :

ÉtapeOctets de Data.dbSSTables
Chargé et vidé sur disque6 206 4951
Après suppression de 90 partitions et flush6 207 3882
Après nodetool compact621 8291
Après gc_grace_seconds = 0 et garbagecollect620 5841

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

InnoDBPostgreSQLOracleCassandra
Unité sur disquepage de 16 Kopage de 8 Kobloc de 8 Ko par défautune SSTable Cassandra immuable
UPDATEsur place, ancienne version dans l’undoune nouvelle version de tuple dans la tablesur place, image avant dans l’undoune nouvelle cellule avec un horodatage plus récent, dans une nouvelle SSTable
DELETEenregistrement marqué, purgé plus tardtuple laissé en place jusqu’au VACUUMligne retirée dans le bloc, la marque haute resteun tombstone, une nouvelle écriture
La place revient avecune reconstruction de tableVACUUMSHRINK SPACE ou MOVEle 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

Articles liés