澳门美高梅手机网站Hadoop之相反排索引

5. 参阅链接


  • MapReduce Tutorial
    2.6.0
  • <Hadoop Action>

5. HBase与HDFS


HBase是一个疏散的久远积存的, 多维度的, 排序的映射表, 通过行键, 行键 +
时间戳 或 行键 + 列(列族: 列修饰符)就好稳定突出之多少

本博客采用创作并用版权协议, 要求签署、非商业用途和保持一致.
转载本博客文章要也遵循签名-非经贸用途-保持一致的著作并用协议.

个体博客地址:
http://andrewliu.tk,
欢迎持续关注同友联.

4.1. 集群运行流程

#第一步对文件打包的过程就不详细解释了, 可以参考单机运行流程
#本机文件复制到集群
$ scp -r InvertedIndexer.jar 集群用户名@集群IP地址:集群目的文件夹  #范例: scp -r InvertedIndexer.jar 2015st27@114.212.190.91:WorkSpace

#ssh远程登录集群
$ ssh 集群用户名@集群IP #范例:ssh 2015st27@114.212.190.91

#如果密码正确会登录集群服务器, 集群上运行Jar包
$ hadoop jar WorkSpace/InvertedIndex.jar InvertedIndex /user/input output

2. HBase安装


HBase有单机, 伪分布式, 全分布式运行模式

依赖:

  • 匹配HBase的Hadoop版本
  • Java JDK 1.6+
  • SSH

安装

$ brew install hbase
# 安装在/usr/local/Cellar/hbase/1.0.0

配置HBase

conf/hbase-env.sh设置JAVA_HOME

$ cd /usr/local/Cellar/hbase/1.0.0/libexec/conf
$ vim hbase-env.sh

export JAVA_HOME="/usr/bin/java"

conf/hbase-site.xml装HBase的主导配置

$ vim hbase-site.xml

<configuration>
  <property>
    <name>hbase.rootdir</name>
    //这里设置让HBase存储文件的地方
    <value>file:///Users/andrew_liu/Downloads/hbase</value>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    //这里设置让HBase存储内建zookeeper文件的地方
    <value>/Users/andrew_liu/Downloads/zookeeper</value>
  </property>
</configuration>

/usr/local/Cellar/hbase/1.0.0/bin/start-hbase.sh提供HBase的启动

$ ./start-hbase.sh                                          
starting master, logging to /usr/local/Cellar/hbase/1.0.0/libexec/bin/../logs/hbase-andrew_liu-master-Andrew-liudeMacBook-Pro.local.out

证明是否安装成功

$ jps

3440 Jps
3362 HMaster # 有HMaster则说明安装成功
1885

启动HBase Shell

$ ./bin/hbase shell

HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 1.0.0, r6c98bff7b719efdb16f71606f3b7d8229445eb81, Sat Feb 14 19:49:22 PST 2015

1.8.7-p357 :001 >
1.8.7-p357 :001 > exit  #退出shell

停止HBase运行

$ ./bin/stop-hbase.sh
stopping hbase....................

个体博客地址:
http://andrewliu.tk

5.1. HBase系布局

HBase的服务器系统遵从简单的骨干服务器架设,
HRegion服务器群HBase服务器构成,
Master服务器负责管理所有的HRegion服务器,
而HBase中装有的服务器通过ZooKeeper来开展和谐并处理HBase服务器运行期间可能撞的错误.

HBase逻辑上的表或会见让划分也多个HRegion, 然后存储在HRegion服务器上.

  • HBase不关乎数量的直白删除和创新,
    当Store中之Storefile数量过阈值会触发合并操作
  • HMaster的首要任务是报告每个HRegion服务器它要维护那些HRegion
  • ZooKeeper存储的凡HBase中ROOT表和META表的职位,
    ZooKeeper还承担督察各个机器的状态

元数据子表下三级索引结构: 根子表->用户表的首家数据表->用户表

4. MapReduce实战之相反排索引


倒排索引举凡千篇一律种索引方法,
被用来囤积在全文检索下有单词在一个文档或者同一组文档中之贮存位置的映射.
它是文档检索系统中尽常用之数据结构. 通过倒排索引,
可以因单词快速取得包含这个单词的文档列表。倒排索引主要出于片独组成部分组成:单词词典倒排文件

问题: 使用Hadoop集群测试编写的带词频属性的文档倒排算法,
在统计词语的倒排索引时,
除了而出口带词频属性的倒排索引,请复计起每个词语的平均出现次数(平均出现次数
= 词语在漫天文档中冒出的频数总和 / 包含该词语的文档数)并输出.

出口格式:
用语1 平均出现次数,文档名1:词频;文档名2:词频;文档名3:词频;…
用语2 平均出现次数,文档名1:词频;…
.

import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Iterator;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;


public class InvertedIndex {
    public static class Map 
    extends Mapper<Object, Text, Text, Text> {
        private Text keyWord = new Text();
        private Text valueDocCount = new Text();

        public void map(Object key, Text value, Context context)
        throws IOException, InterruptedException {
            //获取文档
            FileSplit fileSplit = (FileSplit)context.getInputSplit();
            String fileName = fileSplit.getPath().getName();
            StringTokenizer itr = new StringTokenizer(value.toString());
            while(itr.hasMoreTokens()) {
                keyWord.set(itr.nextToken() + ":" + fileName);  // key为key#doc
                valueDocCount.set("1"); // value为词频
                context.write(keyWord, valueDocCount);
            }
        }
    }

    public static class InvertedIndexCombiner
        extends Reducer<Text, Text, Text, Text> {
        private Text wordCount = new Text();
        private Text wordDoc = new Text();
        //将key-value转换为word-doc:词频
        public void reduce(Text key, Iterable<Text> values, 
            Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (Text value : values) {
                sum += Integer.parseInt(value.toString());
            }
            int splitIndex = key.toString().indexOf(":");  // 找到:的位置
            int splitFileName = key.toString().indexOf(".txt.segmented");
            wordDoc.set(key.toString().substring(0, splitIndex));  //key变为单词
            wordCount.set(key.toString().substring(splitIndex + 1, splitFileName) + ":" + sum);  //value变为doc:词频
            context.write(wordDoc, wordCount);
        }
    }

    public static class Reduce
        extends Reducer<Text, Text, Text, Text> {
        private Text temp = new Text();

        public void reduce(Text key, Iterable<Text> values, 
            Context context) throws IOException, InterruptedException {
            int sum = 0;
            int count = 0;
            Iterator<Text> it = values.iterator();
            StringBuilder all = new StringBuilder();
            //形成最终value
            for(;it.hasNext();) { 
                count++;
                temp.set(it.next());
                all.append(temp.toString());  //将一个文档:1添加到总的string value串中
                int splitIndex = temp.toString().indexOf(":");  // 找到:的位置
                temp.set(temp.toString().substring(splitIndex + 1));  //取出词频字符串
                sum += Integer.parseInt(temp.toString());
                if (it.hasNext()) {
                    all.append(";");
                }
            }
            float averageCount = (float)sum / (float)count;
            FloatWritable average = new FloatWritable(averageCount);
            all.insert(0, average.toString() + ",");
            context.write(key, new Text(all.toString()));
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration(); 
        Job job = Job.getInstance(conf, "Inverted Index");  //配置作业名
        //配置作业的各个类
        job.setJarByClass(InvertedIndex.class);
        job.setMapperClass(Map.class);
        job.setCombinerClass(InvertedIndexCombiner.class);
        job.setReducerClass(Reduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
      }
}

每当单机上运行流程可以翻其他一样首博文MapReduce之WordCount

4. HBase Shell


$ hbase shell  #启动HBase Shell

#创建表
> create 'student', 'description', 'course'  #创建表名为student的表, 指明两个列名, 分别为description和course

#信息明细
> list 'student'  #列出list表信息

#插入数据
> put 'student', 'row1', 'description:age', '18'  #意思为在student表row1处插入description:age的数据为18
> put 'student', 'row1', 'description:name', 'liu'
put 'student', 'row1', 'course:chinese', '100'

#一次扫描所有数据
> scan 'student

#使表失效 / 有效
> disable 'student'
> enable 'student'

#删除表(要先disable)
>  drop 'student'

#退出shell
> quit

1. 系统参数配置


经Hadoop的API对各种零件的参数进行部署

  • org.apache.hadoop.conf 系统参数的安排文件处理API
  • org.apache.hadoop.fs 抽象文件系统API
  • org.apache.hadoop.dfs HDFS模块的兑现
  • org.apache.hadoop.mapred MapReduce模块实现
  • org.apache.hadoop.ipc 封装了网络异步I/O的功底模块
  • org.apache.hadoop.io 定义了通用的I/O模块

  • 布出条件


Hadoop分为三栽运行方式: 单机模式, 伪分布模式, 完全分步模式

  • 单机模式安装配备好, 便于调试, 大数据下运行慢
  • 伪分布式模式于地方文件系统运行, 运行HDFS文件系统
  • 全盘分布模式在差不多雅机械的HDFS上运行

  • MapReduce框架


  • Map接口需要派生自Mapper<k1, v1, k2, v2>
  • Reduce接口需要派生自Reducer<k2, v2, k3, v3>

输入输出的数据类型要和集成时设置的数据类型一致,
Map的出口类型要与Reduce的输入型对应.

  • Hadoop集群上之用户作业采用先入先来调度策略
  • Map输出会经过shuffle过程交给Reduce处理
    shuffle对Map结果划分(partition), 排序(sort), 分割(spilt),
    按照不同之分将结果送给对应的Reduce

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class X {
    public static class Map 
    extends Mapper<LongWritable, Text, Text, IntWritable> {
        public void map(LongWritable key, Text value, Context context)
        throws IOException, InterruptedException {
            // Map逻辑
            }
        }
    }

    public static class Reduce
    extends Reducer<Text, IntWritable, Text, IntWritable> {
        public void reduce(Text key, Iterable<IntWritable> values, 
            Context context) throws IOException, InterruptedException {
            // Reduce逻辑
        }
    }

    public int run(String[] args) throws Exception {
        // 运行配置
        Job job = new Job(getConf());
        job.setJarByClass(Score_Process.class);
        job.steJobName("Score_Process");
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setMapperClass(Map.class);
        job.setCombinerClass(Reduce.class);
        job.setReducerClass(Reduce.class);
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        boolean success = job.waitForCompletion(true);
        return success ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int ret = ToolRunner.run(new Score_Process(), args);
        System.exit(ret);
    }
}
    }

    public int run(String[] args) throws Exception {
        Job job = new Job(getConf());
        job.setJarByClass(Score_Process.class);
        job.steJobName("Score_Process");
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setMapperClass(Map.class);
        job.setCombinerClass(Reduce.class);
        job.setReducerClass(Reduce.class);
        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        boolean success = job.waitForCompletion(true);
        return success ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int ret = X.run(new Score_Process(), args);
        System.exit(ret);
    }
}

Mapper和Reducer基类中的外函数:

  1. setup函数(在task启动后数处理前调用同一次于, 对task的大局处理)
  2. cleanup函数(task销毁之前实施)
  3. run函数

    protected void setup(Context context) 
    throws IOException, InterruptedException {
    }
    protected void cleanup(Context context)
    throws IOException, InterruptedException {
    }
    public void run(Context context) throws IOException, InterruptedException {
        setup(context);
        while(context.nextKeyValue()) {
            map(context.getCurrentKey(), context.getCurrentValue(), context);
        }
        cleanup(context);
    }

本博客采用创作并用版权协议, 要求签署、非商业用途与保持一致.
转载本博客文章要为随签字-非商业用途-保持一致的编写并用协议.

5.2. Java API

  • HBaseConfiguration, 通过此类对HBase进行配置
  • HBaseAdmin, 提供一个接口来治本HBase数据库的申信息, 提供创建, 删除表,
    列出表项, 使表有效或无效, 以及丰富或删除列族成员
  • HTableDescriptor, 包含了说明的名和针对应表的列族
  • HColumnDescriptor, 维护关于列族的音信
  • HTable, 用来与HBase表进行通信
  • Put, 用来针对单个行执行长操作
  • Get, 用来博单个行的连锁消息
  • Result, 存储Get或者Scan操作后取得的说明的单行值

  • 参考链接


  • HBase Quick
    Start
  • Hadoop & Hbase on OSX 10.8 Mountain
    Lion
  • HBase –
    Installation
  • <Hadoop Action>
  • Hadoop+HBase
    伪分布式安装配备

1. 宏观首一律的HBase简介


HBase是Hadoop的数据库, 而Hive数据库的管理工具,
HBase具有分布式, 可扩展及面向列存储的特点(冲谷歌BigTable).
HBase可以动用当地文件系统和HDFS文件存储系统,
存储的是高枕无忧之数据(key-value的照射关系).

HBase位于HDFS的上层, 向下提供仓储, 向上提供运算

3. 伪分布式模式

要关闭HBase

修改hbase-env.sh

HBASE_MANAGE_XK = true

修改hbase-site.xml, 设置HBase使用分布式模式运作

<configuration>
  <property>
    <name>hbase.rootdir</name>
    //Here you have to set the path where you want HBase to store its files.
    <value>hdfs://localhost:8020/hbase</value>
  </property>
  <property>
    <name>hbase.cluster.distributed</name>
  <value>true</value>
</property>
</configuration>

hbase.rootdir路线一定要是与hadoop中core-site.xml中fs.default.name相同

change the hbase.rootdir from the local filesystem to the address of
your HDFS instance
—offical quick start

怎两远在安装不同会挑起ERROR: Can't get master address from ZooKeeper; znode data == null错误错误

每当启动HBase之前, 请先启动Hadoop, 使之运行

启动HBase

$ ./start-hbase.sh
$ jps  #验证是否启动成功, 包含HMaster和HRegionServer说明启动成功

6400 DataNode
7872 Jps
7702 HMaster  
7624 HQuorumPeer
6315 NameNode
6508 SecondaryNameNode
6716 NodeManager
7804 HRegionServerHBase 
6623 ResourceManager

苟当起步HBase后, 提示如下

regionserver running as process 4667. Stop it first.
#请执行以下操作
$ kill -9 4667  #这里4667是要杀掉的进程号

起先成功HBase会在HDFS下开创/hbase目录澳门美高梅手机网站

$ hdfs dfs -ls /hbase

发表评论

电子邮件地址不会被公开。 必填项已用*标注