Qu'est ce que Cassandra ?

Présentation

Cassandra est une base de données NoSQL appartenant à la famille des bases de données orientées colonnes. Cassandra est un projet lancé par Facebook en 2007 qui avait atteint les limites des bases de données relationnalles, c'est pour cela qu'ils ont décidé de créer leur propre base de données répondant à leurs besoins. Après 2 ans de développement, ils ont décidé de l'offrir au monde du libre c'est donc devenu un projet open source appartenent à la fondation Apache en 2009.

Cassandra reprend les conceptes de 2 bases de données existantes. La première BigTable, créé par Google, pour son modèle de données orienté colonne et son mécanisme de persistance sur disque, et la seconde Dynamo, créé par Amazon, pour son achitecture distribuée sans noeud maître.

Plusieurs grandes sociétés utilisent Cassandra pour leur application grand public. C'est le cas de Facebook, Twitter, Digg, Cisco WebEx, IBM, etc.

Les avantages

Cassandra est très rapide pour manipuler un volume important de données. Elle permet d'avoir des schémas de données flexible grâce à sa représentation en colonnes. De plus son achitecture lui permet d'évoluer sans problème dans un environnement distribué, elle intégre des mécanismes de réplication de données et la possibilité de mettre en cluster plusieurs serveurs Cassandra.

Pour ses accès disque, Cassandra privilégie toujours les accès séquentiels aux accès aléatoires, ce qui permet d’éviter une partie des latences importantes dues aux mécaniques des disques durs. Ainsi, lors d’une écriture, les données ne sont pas écrites directement sur disque mais stockées dans une table en mémoire ; un ajout dans un commitlog se comportant en append-only (et donc de manière séquentielle) permet d’assurer la durabilité de l’écriture. Lorsque la table en mémoire est pleine, elle est écrite sur le disque.

Les limites

La principale limitation concernant les tailles des colonnes et des super-colonnes, toutes les données pour une valeur de clé, doivent tenir sur le disque d’une seule machine. Parce que la valeur des clés seules détermine les noeuds responsable de la réplication des données, la quantité de données associées à une clé a cette limitation.

Le modèle de données

Présentation

Pour bien comprendre le modèle de données utilisé par Cassandra il est important de définir un certain nombre de termes utilisés par la suite. Tout d'abord le Keyspace s'apparente à un namespace c'est en général le nom donné à votre application. Ensuite, les Column Familly est ce que ressemble le plus aux tables en SQL. Une Key est une clé qui va représenter une ligne. Les Column représente une valeur, elles disposent de 3 champs: son nom, sa valeur et un timestamp représentant la date à laquelle a été inséré cette valeur. Et pour finir, les Super Column qui contiennent une liste de colonnes.

Afin de comprendre au mieux la représentation j'utiliserai dans la suite des illustrations avec des exemples concrèts d'insertion d'information en base. Pour cela je me baserai sur une implémentation en JAVA non complète mais qui permet d'avoir une bonne vision du modèle de représentation.

Les colonnes

Les données sont représentées en colonne comme le montre l'image ci-dessous. Dans une colonne on trouve 3 champs, son nom, sa valeur associée et un entier représenter la date à laquelle la donnée a été inséré dans la colonne.

Voici une simple implémentation en JAVA d'une colonne qui va nous servir pour la suite des explications. Comme vous pouvez le constater on retrouve bien les 3 champs composant une colonne.

    public class Column {

      private String name;
      private String value;
      private Long timestamp;

      public Column(String name, String value) {
      	this.name = name;
      	this.value = value;
      }
    }
    

Les super colonnes

Les super colonnes sont une liste de colonne, si on veut faire le parallèle avec une base SQL cela représente une ligne. On retrouve cette correspondance clé-valeur, la clé permet d'identifier la super colonne tandis que la valeur est la liste des colonnes qui la compose.

Pour son implémentation JAVA notre super colonne est composée d'un nom correspondant à sa clé et une Map de colonnes qui sont elle-même identifiées par une clé correspondant au nom de la colonne.

    public class SuperColumn {

    	private String name;
    	private Map<String, Column> value;

    	public void setName(String bs) {
    		this.name = bs;
    	}
    	public void setValue(String name, Column value) {
    		this.value.put(name, value);
    	}
    }
    

Pour l'insertion de donnée en utilisant ce modèle on doit tout d'abord initialiser notre super colonne et lui attribuer une clé, nous pouvons ensuite commencer à insérer des données.

    SuperColumn sc = new SuperColumn();
    sc.setName("person1");
    sc.put("firstname", new Column("firstname", "John"));
    sc.put("familyname", new Column("familyname", "Calagan"));

    sc = new SuperColumn();
    sc.setName("person2");
    sc.put("firstname", new Column("firstname", "George"));
    sc.put("familyname", new Column("familyname", "Truffe"));
    

Voila comment les données sont organisées en gardant à l'esprit la notion de clé-valeur. D'après notre exemple nous pouvons voir que nous avons crée 2 super colonnes (person1 et person2) disposant chacune de 2 colonnes qui décrivent le firstname et le familyname de chaque personne.

Les familles de colonnes

Les familles de colonnes sont ce qui ressemble le plus aux tables en SQL. A l'image des super colonnes elles disposent elles aussi d'une Map mais cette fois-ci de super colonnes et non pas de colonnes.

On retrouve le même mécanisme que les super colonnes, c'est uniquement la Map qui change pour y insérer les super colonnes.

    public class ColumnFamily {

    	private String name;
    	private Map<String, SuperColumn> value;
    	
    	public void setName(String bs) {
    		this.name = bs;
    	}
    	public void setValue(String name, SuperColumn value) {
    		this.value.put(name, value);
    	}
    }
		

Pour l'insertion de donnée en utilisant ce modèle, il faut tout d'abord instancier une famille de colonne (ColumnFamily) et lui attribuer un nom qui sera sa clé (dans cet exemple "AddressBook"). On peut ensuite créer autant de super colonne que l'on souhaite et l'ajouter à notre famille de colonne.

    ColumnFamily cf = new ColumnFamily();
    cf.setName("AddressBook");

    SuperColumn row= new SuperColumn();
    row.setName("person1");
    row.put("firstname", new Column("firstname", "John"));
    row.put("familyname", new Column("familyname", "Calagan"));
    cf.setValue("person1", row);

    row = new SuperColumn();
    row.setName("person2");
    row.put("firstname", new Column("firstname", "George"));
    row.put("familyname", new Column("familyname", "Truffe"));
    cf.setValue("person2", row);
		

Voila comment sont organisées les données une fois insérées dans la famille de colonnes.

Les super familles de colonnes

Les super familles de colonnes permettent d'ajouter un niveau d'imbrication supplémentaire. Cela permet de représenter l'ensemble d'une base de données. Dans ce cas, au lieu d'avoir une map de super colonne comme précédemment on dispose d'une map de famille de colonne.

    public class SuperColumnFamily {
    	String name;
      <Map<String, Map<String, SuperColumn>> value;
    }