Todos os produtos
Search

Este produto

    ApsaraDB for HBase:Use o Spark para acessar um cluster do ApsaraDB for HBase Performance-enhanced Edition

    Central de documentação

    ApsaraDB for HBase:Use o Spark para acessar um cluster do ApsaraDB for HBase Performance-enhanced Edition

    Última atualização: Jun 27, 2026

    Ao executar consultas Spark SQL em dados armazenados no ApsaraDB for HBase Performance-enhanced Edition, configure a conexão entre o Spark e o cluster e mapeie o schema da tabela HBase para uma tabela Spark. Este tópico descreve como concluir essa configuração e executar uma consulta Spark SQL em uma tabela HBase.

    Pré-requisitos

    Antes de começar, verifique se você tem:

    Observações de uso

    • Acesso pela internet: substitua o cliente HBase open source pelo cliente do ApsaraDB for HBase antes de acessar o cluster pela internet. Consulte Atualizar o SDK do ApsaraDB for HBase para Java.

    • Acesso via VPC a partir de uma instância do Elastic Compute Service (ECS): garanta que o cluster e a instância ECS atendam às seguintes condições:

      • Ambos devem estar implantados na mesma região. Implante-os na mesma zona para reduzir a latência de rede.

      • Ambos devem pertencer à mesma Virtual Private Cloud (VPC).

    Processo geral

    Para consultar dados em um cluster do ApsaraDB for HBase Performance-enhanced Edition com o Spark SQL:

    1. Configure a conexão do cluster: defina a propriedade hbase.zookeeper.quorum como o Java API endpoint.

    2. Crie uma tabela HBase e insira dados de teste.

    3. Defina um JSON de catálogo para mapear o schema do Spark à tabela HBase.

    4. Crie uma tabela Spark com base na definição de catálogo.

    5. Execute consultas Spark SQL na tabela Spark mapeada.

    Configurar a conexão

    Defina a propriedade hbase.zookeeper.quorum como o Java API endpoint do cluster. Use um dos métodos a seguir.

    Método 1: Arquivo de configuração

    Adicione o seguinte conteúdo ao arquivo hbase-site.xml:

    <configuration>
    <!--
    The Java API endpoint of the cluster.
    Get the endpoint on the Database Connection page in the ApsaraDB for HBase console.
    -->
    <property>
        <name>hbase.zookeeper.quorum</name>
        <value>ld-bp150tns0sjxs****-proxy-hbaseue.hbaseue.rds.aliyuncs.com:30020</value>
    </property>
</configuration>

    Método 2: Objeto de configuração

    Defina a propriedade programaticamente em um objeto Configuration:

    // Create a Configuration object.
Configuration conf = HBaseConfiguration.create();
// The Java API endpoint of the cluster.
// Get the endpoint on the Database Connection page in the ApsaraDB for HBase console.
conf.set("hbase.zookeeper.quorum", "ld-bp150tns0sjxs****-proxy-hbaseue.hbaseue.rds.aliyuncs.com:30020");

    Exemplo

    O exemplo a seguir cria uma tabela HBase, insere dados de teste, mapeia a tabela para uma tabela Spark SQL por meio de uma definição de catálogo em JSON e executa uma consulta COUNT(*).

    As classes HTableDescriptor e HColumnDescriptor foram descontinuadas no Apache HBase 2.x. Em código de produção, use TableDescriptorBuilder e ColumnFamilyDescriptorBuilder.
    test(" test the spark sql count result") {
  // Step 1: Configure the connection.
  var conf = HBaseConfiguration.create
  conf.set("hbase.zookeeper.quorum", "ld-bp150tns0sjxs****-proxy-hbaseue.hbaseue.rds.aliyuncs.com:30020")

  // Step 2: Create an HBase table.
  val hbaseTableName = "testTable"
  val cf = "f"
  val column1 = cf + ":a"
  val column2 = cf + ":b"
  var rowsCount: Int = -1
  var namespace = "spark_test"
  val admin = ConnectionFactory.createConnection(conf).getAdmin()
  val tableName = TableName.valueOf(namespace, hbaseTableName)
  val htd = new HTableDescriptor(tableName)
  htd.addFamily(new HColumnDescriptor(cf))
  admin.createTable(htd)

  // Step 3: Insert test data.
  val rng = new Random()
  val k: Array[Byte] = new Array[Byte](3)
  val famAndQf = KeyValue.parseColumn(Bytes.toBytes(column))
  val puts = new util.ArrayList[Put]()
  var i = 0
  for (b1 <- ('a' to 'z')) {
      for (b2 <- ('a' to 'z')) {
        for (b3 <- ('a' to 'z')) {
          if(i < 10) {
            k(0) = b1.toByte
            k(1) = b2.toByte
            k(2) = b3.toByte
            val put = new Put(k)
            put.addColumn(famAndQf(0), famAndQf(1), ("value_" + b1 + b2 + b3).getBytes())
            puts.add(put)
            i = i + 1
          }
        }
      }
  }
  val conn = ConnectionFactory.createConnection(conf)
  val table = conn.getTable(tableName)
  table.put(puts)

  // Step 4: Create a Spark table using a catalog JSON definition.
  // The catalog maps Spark column names to HBase column families and qualifiers.
  // - "table": specifies the HBase namespace and table name.
  // - "rowkey": identifies which Spark column maps to the HBase row key.
  // - "columns": maps each Spark column to an HBase column family ("cf"),
  //              column qualifier ("col"), and data type ("type").
  //              The row key is also listed here as a named column with cf "rowkey".
  val sparkTableName = "spark_hbase"
  val createCmd = s"""CREATE TABLE ${sparkTableName} USING org.apache.hadoop.hbase.spark
                         |    OPTIONS ('catalog'=
                         |    '{"table":{"namespace":"${namespace}", "name":"${hbaseTableName}"},"rowkey":"rowkey",
                         |    "columns":{
                         |    "col0":{"cf":"rowkey", "col":"rowkey", "type":"string"},
                         |    "col1":{"cf":"f", "col":"a", "type":"string"},
                         |    "col2":{"cf":"f", "col":"b", "type":"string"}}}'
                         |    )""".stripMargin
  println("createCmd: \n" + createCmd + " rows : " + rowsCount)
  sparkSession.sql(createCmd)

  // Step 5: Run a Spark SQL COUNT(*) query.
  val result = sparkSession.sql("select count(*) from " + sparkTableName)
  val sparkCounts = result.collect().apply(0).getLong(0)
  println("sparkCounts : " + sparkCounts)
}

    Próximos passos