Cours Big Data Chap6

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.
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.

• HBase fait partie de l'écosystème Hadoop :
HBASE
HDFS
Data
Consumer
Data
Producer
read write

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

 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

 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.
(RowKey, ColumnFamily, Column qualifier, Timestamp) → Value

Rows are ordered
and accessed by
row key
Different data separated
into ColumnFamilies
All values stores as
byte arrays
Rows can have
different
columns
Cell can have
multiple
versions
Data can be
very “sparse”

Vue logique (1/2)

Vue logique (2/2)

14
Vue physique

• 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.

Tables et régions

• 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

Architecture de Hbase (1/2)

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)

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)

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)
> create 'test', 'data'
0 row(s) in 1.0200 seconds
> list
TABLE
test
=> ["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.
> put 'test', 'row1', 'data:a', 'value 1'
> put 'test', 'row2', 'data:b', 'value 2'
> put 'test', 'row3', 'data:c', 'value 3'

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')
> 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
> 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 2
24

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
> put 'test', 'row1', 'data:a', 'nouvelle valeur 1'
> 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

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
> 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'
> disable 'test'
> drop 'test'
> list
TABLE
=> [] 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)

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
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
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 ».
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.
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);

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.
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();
}

5. Fermeture table et de la connexion de cluster.
34
if (table != null) table.close();
connection.close();

35
Le code complet de notre exemple est fourni en TP.

Cours Big Data Chap6

Contenu connexe

Tendances (20)

Similaire à Cours Big Data Chap6 (20)

Cours Big Data Chap6