Introduction
Vous avez sûrement
entendu parler de BIG DATA ! Il s’agit d’un concept qui consiste à
modéliser, stocker et traiter un ensemble de données hyper volumineuses,
croissantes et hétérogènes (de trillions de données, des milliards de milliards
de données). Qui parle donc de BIG DATA, parle certainement de données à
stocker et à gérer…
On
estime par ailleurs que 80% des données d’une entreprise sont non-structurées et
inexploitées… et le volume augmente de plus en plus rapidement. De plus, les
infrastructures modernes nous permettent de stocker de plus en plus de données à moindre
coût.
Le modèle des bases de données relationnelles a montré leur limite pour stocker
ces données. Ce modèle bien que très puissant, pose le problème du passage à
l’échelle. Des sites comme Google ou
Facebook, possèdent plusieurs centaines de millions d’entrées dans leurs bases
de données et tout autant de visites journalières. Par conséquent, une seule
machine ne peut pas gérer la base de données, de plus pour des raisons de
fiabilité, ces bases de données sont dupliquées pour que le service ne soit pas
interrompu en cas de panne. La méthode consiste donc à rajouter des serveurs
pour dupliquer les données et ainsi augmenter les performances et résister aux
pannes. Seulement, dû aux propriétés fondamentales (ACID) sur lesquelles une
base de données relationnelle repose, cette approche connait des limites.
L’objectif de cet
article n’est pas d’exposer les détails des limites des systèmes
de gestion de base de données traditionnelle (relationnelle) mais de présenter
un système de base de données permettant de gérer de données volumineuse qu’on
appelle communément de NOSQL. Sachant qu’il en existe plusieurs types
(document, graphe, orienté colonne, etc.), nous présentons le type orientée
colonne avec comme exemple HBase.
Base de données orientée colonne ou
base de données orientée Map
Pour une base de donnée orientée colonne, la
notion de colonne n'a pas réellement de sens. Le modèle de gestion des
données repose sur une notion de couple {clé, valeur}. Le nom de la colonne
peut être vue comme la clé. Il y a en effet, aucune notion de colonne telle que
l'on peut l'entendre dans une base de données relationnelle. Donc pour éviter toute ambigüité avec la notion de
colonne pour les bases de données relationnelles, je préfère utiliser le terme
de base de données orientée Map.
Les
données d’une base de données orientée Map (colonne) sont identifiées par une
clé unique (équivalent d’une clé primaire pour les bases de données
relationnelle). Ainsi on associe à ces identifiants un ensemble de données
composées d’un couple clé, valeur (d’où la notion de Map). Dans le monde
relationnel, ces clés sont appelées colonne.
Bien que les données
soient organisées en tables, leur disposition est totalement différente. Ainsi
alors que les colonnes d’une base de données relationnelle sont statiques et
présentes pour chaque ligne, celles d’une base de données orientée colonnes
(disons les clés) sont dynamiques et présentes uniquement pour les lignes
concernées. En d’autres termes, il est possible d’ajouter des colonnes (clés) à
une ligne à tout moment et le coût de stockage d’un
null
est
0.
Prenons un exemple d’une base de données relationnelle,
une table est un ensemble de données organisées en colonnes dont le nombre est
fixe quel que soit le nombre d’enregistrements. Lorsque l’on insère un
enregistrement dans cette table, on spécifie une valeur pour chaque
colonne,
null
étant une valeur par défaut. Voici un exemple de représentation
d’une personne :
Les bases de données orientées colonnes sont
pensées pour stocker des millions de colonnes, ce qui en fait des bases
adaptées au stockage
one-to-many
. Elles sont
bien adaptées par exemple pour le stockage de : messages, posts , commentaires, etc.
Les requêtes pour accéder aux
données sont généralement simples. Il est en effet possible de faire des
requêtes par clé, ou ensemble de clés et d’y adjoindre un prédicat sur un
intervalle de clés. Un exemple de requête typique : toutes les valeurs des
clés (colonnes) de l’identifiant 15 ou toutes les valeurs des clés (colonnes)
dont le nom est compris entre "aaa" et "abb" pour
l’identifiant 178 ou la valeur de la clé "aaa" pour les
identifiants 26 à 31.
HBase : un exemple de base de
données orientée colonne
Hbase est un exemple de SGBD orienté colonne. Il a
été calqué sur les travaux de BigTable de Google et se repose sur le système de
fichier distribué (HDFS : hadoop distributed file system). HDFS est caractérise par une haute tolérance
aux pannes et permet un accès très rapide aux données. C'est un système de
fichier adapté aux applications gérant de grands ensembles de données. HBase est particulièrement bien adaptée pour le
stockage de très grandes collections et a des performances exceptionnelles pour des
lectures et écritures massives de données. Elle a été conçue
pour stocker de très grandes tables (des
milliards d'enregistrement avec des millions de colonnes) de données.
Les données sont organisées dans des tables
identifiées par une simple chaîne de caractère (le nom de la table). Une table
est composée d'un ensemble de lignes appelée Row. Chaque Row (ligne)
est identifiée par un identifiant unique appelé ROWKEY (Identifiant). Dans Hbase, une ROWKEY n'a pas de type spécifique (c'est un simple tableau
d'octets).
Une ligne Hbase est d'une part identifiée par une ROWKEY et composée d'un ensemble de
couple clé-valeur (colonne – valeur associée). Dans le jargon Hbase, la clé est
appelée Column Qualifier. On pourra
donc parler du couple (Column Qualifier,
valeur) appelé également Cell.
L'ensemble
de clé ou Column Qualifier que compose une ligne, est organisé en un groupe
homogène appelé Column Family (il
s'agit juste de regroupement d'un ensemble de clés). Ce regroupement permet de
tracer une séparation sémantique entre les clés. Par exemple, pour une table
Personne, on pourra créer 2 Column
Family : - Identité composée des clés
(Column Qualifier) : nom,
prénom, age ; - Adresse composée : numéro de la rue, nom de la rue,
code postal, ville. Une ligne Hbase est donc composée d'un ensemble de
Column Family qui est composée d'un ensemble de Cell (couple clé-valeur ou Column
Qualifier, valeur).
Les Column
Family ne sont pas aussi dynamiques que Column Qualifier. Elles doivent être définies lors de la création
de la table et ne doivent pratiquement pas changer en cours de route. À
l’opposé, les Column Qualifier peuvent
être instanciées et ajoutées aux tables (aux Column Family) à tout moment.
Parmi les concepts intéressants de HBase, on
retrouve le versonning des valeurs. En effet, une clé (Column Qualifier) peut avoir plusieurs valeurs avec une version
associée à chaque valeur. Les versions sont identifiées par leur timestamp (de type long). Le nombre de
versions est configuré lors de la définition d'une Column Family. Par défaut, ce nombre est égal à trois.
Exemple :
La suite de cet article est de vous présenter une introduction HBase SHELL & HBase JAVA API pour effectuer de requête ...
Aucun commentaire:
Enregistrer un commentaire