Amal ABID – Cours GI3 ENIS 1
Chapitre 6
HBase
• HBase est une base de données :
Distribuée
À haute performance
Extrêmement évolutive
Tolérante aux fautes (+ pas de SPOF)
Non-relationnelle (NoSQL- Orientée Colonnes)
• Elle peut être utilisée à la fois comme :
Base de données temps réel.
Base de données pour une lecture intensive pour les systèmes décisionnels.
• HBase s’inspire de BigTable de Google pour son architecture, son
modèle de données orienté colonne et son mécanisme de persistance sur
le disque.
Amal ABID – Cours GI3 ENIS 2
Présentation de HBase (1/4)
• HBase est la base de données de Hadoop.
La base de données Big Data libre qui s'installe sur un cluster Hadoop.
• HBase utilise le système de fichiers distribué de Hadoop (HDFS) pour distribuer
et répliquer les données des tables sur l'ensemble des machines du cluster Hadoop.
• HBase 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.
• Elle est particulièrement bien adaptée pour le stockage de très grandes collections
de documents ou pour conserver de grandes quantités de données pour faire du
profiling.
• HBase est un projet logiciel libre disponible sous licence Apache 2.0.
Amal ABID – Cours GI3 ENIS 3
Présentation de HBase (2/4)
Amal ABID – Cours GI3 ENIS 4
Présentation de HBase (3/4)
• HBase fait partie de l'écosystème Hadoop :
HBASE
HDFS
Data Consumer
Data Producer
read write
Amal ABID – Cours GI3 ENIS 5
Présentation de HBase (4/4)
Le modèle de données se base sur les concepts suivants :
Table
• Dans HBase les données sont organisées dans des tables.
• Les noms de tables sont des chaînes de caractères.
Row
• Dans chaque table les données sont organisées dans des lignes.
• Une lignes est identifiée (indexée) par une clé unique (RowKey).
• La Rowkey n’a pas un type, elle est traitée comme un tableau d’octets.
6
Modèle de stockage des données (1/11)
Amal ABID – Cours GI3 ENIS
Column (Column qualifier)
• Pour chaque RowKey un nombre illimité d'attributs peuvent être stockés dans les
colonnes. Il n'y a pas de schéma strict par rapport aux colonnes. De nouvelles
colonnes peuvent être ajoutées au runtime.
• Le column qualifier permet l’accès aux données. Ce dernier n’est pas spécifié à
la création de la table mais plus tôt à l’insertion de la donnée.
• Comme les Rowkeys, le Column qualifier n’est pas typé, il est traité comme un
tableau d’octets.
Column Family
• Les colonnes sont regroupées en ColumnFamilies. Chaque ligne de la table a les
mêmes ColumnFamilies, qui peuvent être peuplées ou pas.
• Les ColumnFamilies doivent être définies lors de la création de la table et ne
peuvent pas être modifiés par la suite.
• Les noms des ColumnFamilies sont des chaines de caractères.
7Amal ABID – Cours GI3 ENIS
Modèle de stockage des données (2/11)
Cell
• La combinaison du RowKey, de la Column Family ainsi que la Column qualifier
identifie d’une manière unique une cellule.
• Les données stockées dans une cellule sont appelée les valeurs de cette cellule.
• Les valeurs n’ont pas de type, ils sont toujours considérés comme tableau
d’octets.
Version
• Les valeurs au sein d’une cellule sont versionnées. Chaque version est identifiée
par un Timestamp.
• Une fois la valeur est écrite dans HBase, Elle ne peut pas être modifiée. Au lieu
de cela une autre version avec un Timestamp plus récent peut être ajoutée.
• Un Timestamp est de type long.
8Amal ABID – Cours GI3 ENIS
Modèle de stockage des données (3/11)
Null (Sparse) :
• Contrairement aux bases de données relationnelles, une colonne qui n’a pas de
valeur n’est pas matérialisée (aucun stockage n’est nécessaire en cas d’une valeur
null pour une colonne).
Par conséquent, la combinaison suivante permet de retrouver une
«cellule» :
Avec toutes ces informations, nous avons la possibilité de récupérer une
donnée précise dans la base de données.
Amal ABID – Cours GI3 ENIS 9
(RowKey, ColumnFamily, Column qualifier, Timestamp) → Value
Modèle de stockage des données (4/11)
Amal ABID – Cours GI3 ENIS 10
Modèle de stockage des données (15/11)
Amal ABID – Cours GI3 ENIS 11
Rows are ordered and accessed by
row keyDifferent data separated
into ColumnFamiliesAll values stores as
byte arrays
Rows can have different columns
Cell can have multiple versions
Data can be very “sparse”
Modèle de stockage des données (6/11)
Vue logique (1/2)
Amal ABID – Cours GI3 ENIS 12
Modèle de stockage des données (7/11)
Amal ABID – Cours GI3 ENIS 13
Vue logique (2/2)
Modèle de stockage des données (8/11)
14
Vue physique
Modèle de stockage des données (9/11)
• Il est très important de bien concevoir la taxonomie de clés dans HBase.
• Puisque dépendamment comment ces derniers sont conçus, il sera plus facile
de contrôler comment et où les données sont sauvegardées.
• Aussi il sera plus facile d’accéder aux données.
• Il est à noter que les enregistrements dans HBase sont toujours ordonnés
selon la valeur lexicographique, c.-à-d. en ordre alphabétique.
Amal ABID – Cours GI3 ENIS 15
Modèle de stockage des données (10/11)
Amal ABID – Cours GI3 ENIS 16
Tables et régions
Modèle de stockage des données (11/11)
• HBase, comme Hadoop, vise à fonctionner sur un cluster de machines.
• C’est le serveur Master qui reçoit la requête, et qui par la suite contacte les
RegionServers. L’ensemble des données sont réparties sur l’ensemble des
RegionServers pour éviter de charger une seule machine à chaque requête.
Composants principaux de HBase
Amal ABID – Cours GI3 ENIS 17
Architecture de Hbase (1/2)
Amal ABID – Cours GI3 ENIS 18
19
Architecture de Hbase (2/2)
Pour manipuler les données, HBase propose plusieurs méthodes :
• HBase Shell
• API Java
• Web-services RESTful (Ruby, Php, Python, Perl, C++,..)
– Thrift
– Stargate
Manipulation des données (1/16)
Amal ABID – Cours GI3 ENIS 20
Toutes les opérations de base d’une base de données relationnelle sont aussi
supportées par HBase :
• Ajout et modification de données « PUT »
• Lecture de données « GET »
• Suppression de données « DELETE »
• Recherche de données « SCAN »
Manipulation des données - Opérations (2/16)
Amal ABID – Cours GI3 ENIS 21
1. Connexion au shell Hbase
2. Création d’une table « test» avec une famille de colonnes « data ».
3. Vérification de la création de la table en listant les tables de la base.
Manipulation des données – HBase Shell (3/16)
Amal ABID – Cours GI3 ENIS 22
> create 'test', 'data'
0 row(s) in 1.0200 seconds
> list
TABLE
test
1 row(s) in 1.0570 seconds
=> ["test"]
$ hbase shell
hbase(main):001:0>
4. Insertion des données dans trois lignes et trois colonnes différentes
(dans la même famille de colonnes « data »)
Remarque : Nous avons inséré trois valeurs. Le premier élément inséré est à
«row1», colonne «data:a» avec une valeur «valeur1». Les colonnes de HBase
sont composés d'un préfixe FamilyColumn, «data» dans cet exemple, suivi de
deux points et un suffixe Colonm Qualifier, «a» dans ce cas.
Manipulation des données – HBase Shell (4/16)
Amal ABID – Cours GI3 ENIS 23
> put 'test', 'row1', 'data:a', 'value 1'
0 row(s) in 0.0390 seconds
> put 'test', 'row2', 'data:b', 'value 2'
0 row(s) in 0.0150 seconds
> put 'test', 'row3', 'data:c', 'value 3'
0 row(s) in 0.0090 seconds
5. Affichage de la table (toutes les données à la fois).
6. Affichage d’une ligne ('row2')
7. Affichage de la valeur d’une cellule ('row2'-'data:b')
Manipulation des données – HBase Shell (5/16)
> scan 'test'
ROW COLUMN+CELL
row1 column=data:a, timestamp=1413741061087, value=value 1
row2 column=data:b, timestamp=1413741095382, value=value 2
row3 column=data:c, timestamp=1413741107667, value=value 3
3 row(s) in 0.0450 seconds
> get 'test', 'row2'
COLUMN CELL
data:b timestamp=1413741095382, value=value 2
> get 'test', 'row2', 'data:b'
COLUMN CELL
data:b timestamp=1413741095382, value=value 224
8. Modification de la valeur d’une cellule et affichage du resultat
9. Ajout d’une valeur dans une cellule et affichage du résultat
Manipulation des données – HBase Shell (6/16)
> put 'test', 'row1', 'data:a', 'nouvelle valeur 1'
0 row(s) in 0.0740 seconds
> put 'test', 'row2', 'data:bb', 'valeur 22'
get 'test', 'row1', 'data:a'
COLUMN CELL
data:a timestamp=1413744793745, value=nouvelle valeur1
> get 'test', 'row2'
COLUMN CELL
data:b timestamp=1413741095382, value=valeur 2
data:bb timestamp=1413745401122, value=valeur 22
Amal ABID – Cours GI3 ENIS 25
10. Suppression de la cellule 'row3'-'data:c' et lister le contenu de la table
11. Suppression de la famille de colonne 'data' de la table
Manipulation des données – HBase Shell (7/16)
> delete 'test', 'row3', 'data:c'
> scan 'test'
ROW COLUMN+CELL
row1 column=data:a, timestamp=1413744793745, value=nouvelle valeur1
row2 column=data:b, timestamp=1413741095382, value=valeur 2
row2 column=data:bb, timestamp=1413745401122, value=valeur 22
> disable 'test'
> alter 'test', 'delete' => 'data'
Updating all regions with the new schema...
1/1 regions updated.
Done.
> enable 'test'
> scan 'test'
ROW COLUMN+CELL
0 row(s) in 0.0120 seconds 26
Remarques :
1- Si vous voulez supprimer une table ou modifier ses paramètres, vous devez
désactiver d’abord la table, en utilisant la commande "disable". Par la suite vous
pouvez le réactiver en utilisant la commande "enable".
2- La suppression d’une famille de colonne ne peut pas être effectuée si vous
avez une seule famille de colonne dans la table.
12. Suppression de la table 'test'
Manipulation des données – HBase Shell (8/16)
> disable 'test'
0 row(s) in 0.4880 seconds
> drop 'test'
0 row(s) in 0.3080 seconds
> list
TABLE
0 row(s) in 0.0300 seconds
=> []27
• HBase est écrit en Java, par conséquent, il fournit une API Java pour communiquer
avec HBase. L'API Java est le moyen le plus rapide pour y communiquer.
• Il existe deux API pour Hbase : Java Admin API et Java Client API.
1. Java Admin API couvre les tâches utilisées pour gérer les tables : CREATE (Table,
ColomnFamilies), LIST, DISABLE, ENABLE, DESCRIBE & ALTER, DROP a
Table.
2. Java Client API couvre les tâches utilisées pour manipuler les données et effectuer
des opérations CRUD sur des tables Hbase : CREATE, UPDATE, READ, DELETE
a Data and SCAN
• Dans ce cours, les tâches administratives seront faites via le shell, et l’API Client
Java sera utilisée pour la manipulation des données.
Manipulation des données – Java (9/16)
Amal ABID – Cours GI3 ENIS 28
1. Création d’un objet de config
Cette instruction retourne un objet Configuration qui a lu la configuration de HBase à
partir des fichiers de hbase-site.xml et hbase-default.xml trouvés sur le classpath du
programme.
2. Création d’une connexion
Manipulation des données – Java (10/16)
Amal ABID – Cours GI3 ENIS 29
Configuration config = HbaseConfiguration.create(config);
Connection connection =
ConnectionFactory.createConnection(config);
// Créé un objet de configuration Hadoop.
Configuration config=new Configuration();
- Put est une opération de sauvegarde pour une seule ligne.
- L'ID de la ligne est représenté comme des octets ("bytes").
- Le développeur est responsable de la conversion de l'ID à des octets.
- HBase est livré avec une classe qui gèrent diverses conversions de et vers "bytes"
(org.apache.hadoop.hbase.util.Bytes)
- D’autres paramètres optionnelles peuvent être ajoutées, comme le Timestamp et le
Column Qualifier. Put put1 = new Put(Bytes.toBytes("row1"), [timestamp,
rowlock]);
3. Création d'une instance Table qui vous connecte à la table
"myLittleHBaseTable"
4. Les Opérations : Put, Get, Scan
a- Création d’une instance Put
Manipulation des données – Java (11/16)
30
Table table =
connection.getTable(TableName.valueOf("myLittleHBaseTable"));
Put p = new Put(Bytes.toBytes("myLittleRow"));
b- Ajout des valeurs des cellules et leurs coordonnées
- Options de la méthode add : put.add (columnfamily, column, value), columnfamily,
column, timestamp ,value).
- ColumnFamily, Column, et la Valeur sont des « bytes » . Le développeur est responsable
de leur convertir au format binaire.
c- Appel de la méthode « put » de l’instance « table »
- Une fois que vous avez préparé votre instance « Put » avec toutes les mises à jour que
vous voulez établit, vous pouvez ainsi le commettre à travers la méthode « put » de
l’instance « table ».
Manipulation des données – Java (12/16)
Amal ABID – Cours GI3 ENIS 31
table.put(p);
p.addColumn(Bytes.toBytes("myLittleFamily"),
Bytes.toBytes("someQualifier"),Bytes.toBytes("Some Value"));
d- Affichage de la cellule ajoutée
- Pour récupérer les données que vous venez d'écrire, utilisez l’instance de la classe
« Get».
- Les valeurs qui retournent de la méthode « get » de l’instance « table » sont des
instances de résultat.
Manipulation des données – Java (13/16)
32
Get g = new Get(Bytes.toBytes("myLittleRow"));
Result r = table.get(g);
byte[] value =
r.getValue(Bytes.toBytes("myLittleFamily"),
Bytes.toBytes("someQualifier"));
String valueStr = Bytes.toString(value);
System.out.println("GET: " + valueStr);
Amal ABID – Cours GI3 ENIS
e- Parcours et affichage de la table créée
- Parfois, vous ne saurez pas la ligne que vous cherchez. Dans ce cas, vous utilisez un
"Scanner". Cela vous donnera un "curseur" qui ressemble au contenu de la table.
Manipulation des données – Java (14/16)
33
Scan s = new Scan();
s.addColumn(Bytes.toBytes("myLittleFamily"),
Bytes.toBytes("someQualifier"));
ResultScanner scanner = table.getScanner(s);
try {
for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
System.out.println("Found row: " + rr);
}
} finally {
scanner.close();
}
Amal ABID – Cours GI3 ENIS
5. Fermeture table et de la connexion de cluster.
Manipulation des données – Java (15/16)
34
if (table != null) table.close();
Amal ABID – Cours GI3 ENIS
connection.close();
Manipulation des données – Java (16/16)
35Amal ABID – Cours GI3 ENIS
Le code complet de notre exemple est fourni en TP.