Utilisez HBase dans le langage Go pour implémenter des applications de base de données NoSQL efficaces

Avec l’avènement de l’ère du big data, le stockage et le traitement de données massives sont particulièrement importants. En termes de bases de données NoSQL, HBase est actuellement une solution largement utilisée. En tant que langage de programmation statiquement fortement typé, le langage Go est de plus en plus utilisé dans des domaines tels que le cloud computing, le développement de sites Web et la science des données en raison de sa syntaxe simple et de ses excellentes performances. Cet article expliquera comment utiliser HBase en langage Go pour implémenter des applications de base de données NoSQL efficaces.

1. Introduction à HBase

HBase est un système de stockage de données distribué basé sur des colonnes, hautement évolutif et hautement fiable. Il fonctionne sur un cluster Hadoop et peut gérer des tâches de stockage et de traitement de données à très grande échelle. Le modèle de données de HBase est similaire à Bigtable de Google, une base de données NoSQL basée sur des colonnes. HBase présente les caractéristiques suivantes :

• Basé sur la plateforme informatique distribuée Hadoop, il peut stocker des données au niveau PB sur des milliers de machines.
• Prend en charge la lecture et l'écriture rapides des données, le stockage et l'accès sont très rapides.
• Prend en charge plusieurs méthodes d'accès aux données telles que la lecture aléatoire, la lecture par analyse, l'analyse de table complète, etc.
• Prend en charge le stockage et l'interrogation de données multiversions et peut traiter efficacement les données de séries chronologiques.
• Prend en charge l'expansion horizontale et peut facilement étendre les capacités de stockage et de traitement.
• Fournit une série de filtres et d'encodeurs pour prendre en charge le traitement et la transformation des données.

2. Le langage Go exploite HBase

Le langage Go fournit la bibliothèque Thrift pour implémenter des opérations sur HBase. Thrift est un framework multilingue sous Apache qui peut générer du code dans plusieurs langages, notamment Java, Python, Ruby, C++, etc. Thrift permet aux développeurs de définir des services RPC à l'aide d'un langage de définition simple et de générer du code côté client et côté serveur. Dans le langage Go, vous pouvez utiliser la bibliothèque thriftgo pour le développement.

2.1 Installer Thrift

Avant d'utiliser Thrift, vous devez d'abord installer le compilateur Thrift. Vous pouvez télécharger la version correspondante du compilateur depuis le site officiel de Thrift, la décompresser et l'ajouter aux variables d'environnement.

2.2 Définir l'interface Thrift de HBase

Le fichier de définition Thrift est appelé IDL (Interface Definition Language, langage de définition d'interface). Le fichier d'interface Thrift de HBase est Hbase.thrift. Il peut être téléchargé depuis la documentation officielle ou depuis github via la commande git clone.

$ git clone https://github.com/apache/hbase

Toutes les définitions d'interface Thrift de HBase peuvent être trouvées dans le fichier Hbase.thrift, et nous pouvons choisir de les utiliser selon nos besoins. Par exemple, ce qui suit est une définition d'interface qui répertorie les tables :

struct TColumnDescriptor {

1: required binary name,
2: binary value,
3: bool __isset.value,
4: optional CompressionType compression,
5: optional int32 maxVersions,
6: optional int32 minVersions,
7: optional int32 ttl,
8: optional bool inMemory,
9: optional BloomType bloomFilterType,
10: optional int32 scope,
11: optional bool __isset.compression,
12: optional bool __isset.maxVersions,
13: optional bool __isset.minVersions,
14: optional bool __isset.ttl,
15: optional bool __isset.inMemory,
16: optional bool __isset.bloomFilterType,
17: optional bool __isset.scope

}

TColumnDescriptor peut être considéré comme la définition d'une famille de colonnes, qui comprend le nom de la famille de colonnes, le type de compression, la version maximale et le délai d'expiration. , ainsi que le stockage en mémoire et d'autres propriétés. En langage Go, vous devez utiliser le compilateur Thrift pour compiler le fichier Hbase.thrift en code du langage Go. La bibliothèque thriftgo doit être installée avant la compilation.

$ go get -u github.com/apache/thrift/lib/go/thrift

Ensuite, exécutez la commande suivante dans le répertoire HBase pour générer le code de langue Go.

$ thrift --gen go src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift

Après avoir exécuté la commande, vous verrez tout le code de langue Go généré dans le répertoire gen-go généré document.

2.3 Connexion au serveur HBase

Pour vous connecter au serveur HBase, vous devez créer un lien de transport et utiliser un pool de connexions pour gérer le lien. Le pool de connexions peut gérer plusieurs liaisons de transport et la réutilisation de ces liaisons peut améliorer le débit global. Voici un exemple de code pour se connecter à HBase :

package main

import (

"context"
"fmt"
"sync"

"git.apache.org/thrift.git/lib/go/thrift"
"hbase"

)

type pool struct {

hosts    []string         // HBase服务器地址列表
timeout  thrift.TDuration // 连接超时时间
size     int              // 连接池大小
pool     chan *conn       // 连接池
curConns int              // 当前连接池中的连接数

lock sync.RWMutex

}

type conn struct {

trans hbase.THBaseServiceClient // HBase客户端
used  bool                      // 是否被使用

}

// NewPool initialise le pool de connexion
func NewPool(hosts []string, timeout int, size int) *pool {

p := &pool{
    hosts:    hosts,
    timeout:  thrift.NewTDuration(timeout * int(thrift.MILLISECOND)),
    size:     size,
    pool:     make(chan *conn, size),
    curConns: 0,
}

p.lock.Lock()
defer p.lock.Unlock()

for i := 0; i < size; i++ {
    p.newConn()
}

return p

}

// AddConn Ajouter une connexion
func (p *pool) AddConn() {

p.lock.Lock()
defer p.lock.Unlock()

if p.curConns < p.size {
    p.newConn()
}

}

// Fermer Fermer la connexion Pool
func (p *pool) Close() {

p.lock.Lock()
defer p.lock.Unlock()

for i := 0; i < p.curConns; i++ {
    c := <-p.pool
    _ = c.trans.Close()
}

}

// GetConn Obtenir la connexion
func (p pool) GetConn() (conn, erreur) {

select {
case conn := <-p.pool:
    if conn.used {
        return nil, fmt.Errorf("Connection is already in use")
    }

    return conn, nil
default:
    if p.curConns >= p.size {
        return nil, fmt.Errorf("Connection pool is full")
    }

    p.lock.Lock()
    defer p.lock.Unlock()

    return p.newConn(), nil
}

}

// PutConn Return Connect
func (p pool) PutConn(conn conn) {

conn.used = false
p.pool <- conn

}

// newConn Créer une connexion
func (p pool) newConn() conn {

socket := thrift.NewTSocketTimeout(p.hosts[0], p.timeout)
transport := thrift.NewTFramedTransport(socket)
protocol := thrift.NewTBinaryProtocolTransport(transport, true, true)
client := hbase.NewTHBaseServiceClientFactory(transport, protocol)

if err := transport.Open(); err != nil {
    return nil
}

p.curConns++

return &conn{
    trans: client,
    used:  false,
}

}

Utilisation l'exemple de code ci-dessus, il est possible de créer un pool de connexions pour se connecter à HBase. Après avoir défini des paramètres tels que les hôtes, le délai d'attente et la taille, vous pouvez utiliser la méthode NewPool pour créer un pool de connexions. Les connexions dans le pool de connexions peuvent être obtenues à l'aide de la méthode GetConn et renvoyées par la méthode PutConn.

2.4 Exploiter les données

Après vous être connecté au serveur HBase, vous pouvez utiliser la connexion dans le pool de connexions pour opérer sur les données. Voici quelques exemples d'opérations sur les données :

//Obtenir une liste de tables
func GetTableNames(c *conn) ([]string, error) {

names, err := c.trans.GetTableNames(context.Background())
if err != nil {
    return nil, err
}

return names, nil

}

//Obtenir une ligne de données
func GetRow (c conn, tableName string, rowKey string) (hbase.TRowResult_, erreur) {

// 构造Get请求
get := hbase.NewTGet()
get.Row = []byte(rowKey)
get.TableName = []byte(tableName)

result, err := c.trans.Get(context.Background(), get)
if err != nil {
    return nil, err
}

if len(result.Row) == 0 {
    return nil, fmt.Errorf("Row %s in table %s not found", rowKey, tableName)
}

return result, nil

}

// Écrire une ligne de données
func PutRow(c *conn, tableName string, rowKey string, columns map[ string]map [string][]byte,

         timestamp int64) error {
// 构造Put请求
put := hbase.NewTPut()
put.Row = []byte(rowKey)
put.TableName = []byte(tableName)

for cf, cols := range columns {
    family := hbase.NewTColumnValueMap()

    for col, val := range cols {
        family.Set(map[string][]byte{
            col: val,
        })
    }

    put.ColumnValues[[]byte(cf)] = family
}

put.Timestamp = timestamp

_, err := c.trans.Put(context.Background(), put)
if err != nil {
    return err
}

return nil

}

La méthode GetTableNames peut obtenir une liste de tables, la méthode GetRow peut obtenir une ligne de données et la méthode PutRow peut écrire une ligne de données. a noté que la requête TPut doit être construite dans la méthode PutRow.

3. Résumé

Cet article présente comment utiliser HBase en langage Go pour implémenter des applications de base de données NoSQL efficaces. De la définition de l'interface Thrift, de la connexion au serveur HBase aux données d'exploitation, il explique étape par étape comment utiliser le langage Go pour faire fonctionner HBase. Grâce aux hautes performances du langage Go et aux fonctionnalités multilingues du framework Thrift, des applications de base de données NoSQL efficaces peuvent être créées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!