C4.5+聚类+SVM+关联+EM+PageRank+迭代+kNN+NB+分类笔记

  1. C4.5算法
    C4.5是做什么
    C4.5 以决策树的形式构建了一个分类器。
    什么是分类器
    分类器是进行数据挖掘的一个工具,它处理大量需要进行分类的数据,并尝试预测新数据所属的类别。 ru:假定一个包含很多病人信息的数据集。我们知道每个病人的各种信息,比如年龄、脉搏、血压、最大摄氧量、家族病史等。这些叫做数据属性。
    现在:
    给定这些属性,我们想预测下病人是否会患癌症。病人可能会进入下面两个分类:会患癌症或者不会患癌症。算法负责告诉我们每个病人的分类。
    做法:
    用一个病人的数据属性集和对应病人的反馈类型,C4.5构建了一个基于新病人属性预测他们类型的决策树。
    什么是决策树呢?
    决策树学习是创建一种类似与流程图的东西对新数据进行分类。
    基本原则:
    流程图的每个环节都是一个关于属性值的问题,并根据这些数值,病人就被分类了。你可以找到很多决策树的例子。
    这属于监督学习算法,因为训练数据是已经分好类的。使用分好类的病人数据,C4.5算法不需要自己学习病人是否会患癌症。
    C4.5算法和决策树系统区别
    首先,C4.5算法在生成信息树的时候使用了信息增益。
    其次,尽管其他系统也包含剪枝,C4.5使用了一个单向的剪枝过程来缓解过渡拟合。剪枝给结果带来了很多改进。 再次,C4.5算法既可以处理连续数据也可以处理离散数据。最后,不完全的数据用算法自有的方式进行了处理。
    决策树最好的卖点是他们方便于翻译和解释。他们速度也很快,是种比较流行的算法。输出的结果简单易懂。

  2. k 均值聚类算法
    K-聚类算法从一个目标集中创建多个组,每个组的成员都是比较相似的。这是个想要探索一个数据集时比较流行的聚类分析技术。
    什么是聚类分析
    聚类分析属于设计构建组群的算法,这里的组成员相对于非组成员有更多的相似性。在聚类分析的世界里,类和组是相同的意思。
    如:假设我们定义一个病人的数据集。在聚类分析里,这些病人可以叫做观察对象。我们知道每个病人的各类信息,比如年龄、血压、血型、最大含氧量和胆固醇含量等。这是一个表达病人特性的向量。
    基本认为一个向量代表了我们所知道的病人情况的一列数据。这列数据也可以理解为多维空间的坐标。脉搏是一维坐标,血型是其他维度的坐标等等。
    Kmeans算法更深层次的这样处理问题:
    1.k-means 算法在多维空间中挑选一些点代表每一个 k 类。他们叫做中心点。
    2.每个病人会在这 k 个中心点中找到离自己最近的一个。我们希望病人最靠近的点不要是同一个中心点,所以他们在靠近他们最近的中心点周围形成一个类。
    3.我们现在有 k 个类,并且现在每个病人都是一个类中的一员。
    4.之后k-means 算法根据它的类成员找到每个 k 聚类的中心
    5.这个中心成为类新的中心点。
    6.因为现在中心点在不同的位置上了,病人可能现在靠近了其他的中心点。换句话说,他们可能会修改自己的类成员身份。
    7.重复2-6步直到中心点不再改变,这样类成员也就稳定了。这也叫做收敛性。
    k-means 可以认为是非监督学习的类型。并不是指定分类的个数,也没有观察对象该属于那个类的任何信息
    k-means 关键卖点是它的简单。它的简易型意味着它通常要比其他的算法更快更有效,尤其是要大量数据集的情况下更是如此。
    改进:
    k-means 可以对已经大量数据集进行预先聚类处理,然后在针对每个子类做成本更高点的聚类分析。k-means 也能用来快速的处理“K”和探索数据集中是否有被忽视的模式或关系。
    k means算法的两个关键弱点分别是它对异常值的敏感性和它对初始中心点选择的敏感性。

  3. 支持向量机
    支持向量机(SVM)获取一个超平面将数据分成两类。除了不会使用决策树以外,SVM与 C4.5算法是执行相似的任务的。
    超平面(hyperplane)是个函数,类似于解析一条线的方程。实际上,对于只有两个属性的简单分类任务来说,超平面可以是一条线的。
    其实事实证明: SVM 可以使用一个小技巧,把你的数据提升到更高的维度去处理。一旦提升到更高的维度中,SVM算法会计算出把你的数据分离成两类的最好的超平面。
    简单的例子。我发现桌子上开始就有一堆红球和蓝球,如果这这些球没有过分的混合在一起,不用移动这些球,你可以拿一根棍子把它们分离开。 当在桌上加一个新球时,通过已经知道的棍字的哪一边是哪个颜色的球,你就可以预测这个新球的颜色了。
    SVM 算法可以算出这个超平面的方程。 如果事情变得更复杂该怎么办?当然了,事情通常都很复杂。如果球是混合在一起的,一根直棍就不能解决问题了。
    通过使用核函数(kernel),我们在高维空间也有很棒的操作方法。这张大纸依然叫做超平面,但是现在它对应的方程是描述一个平面而不是一条线了。
    那么在桌上或者空中的球怎么用现实的数据解释呢?桌上的每个球都有自己的位置,我们可以用坐标来表示。打个比方,一个球可能是距离桌子左边缘20cm 距离底部边缘 50 cm,另一种描述这个球的方式是使用坐标(x,y)或者(20,50)表达。x和 y 是代表球的两个维度。
    可以这样理解:如果我们有个病人的数据集,每个病人可以用很多指标来描述,比如脉搏,胆固醇水平,血压等。每个指标都代表一个维度。
    基本上,SVM 把数据映射到一个更高维的空间然后找到一个能分类的超平面。
    类间间隔(margin)经常会和 SVM 联系起来,类间间隔是什么呢?它是超平面和各自类中离超平面最近的数据点间的距离。在球和桌面的例子中,棍子和最近的红球和蓝球间的距离就是类间间隔(margin)。
    SVM 的关键在于,它试图最大化这个类间间隔,使分类的超平面远离红球和蓝球。这样就能降低误分类的可能性。
    SVM 属于监督学习。因为开始需要使用一个数据集让 SVM学习这些数据中的类型。只有这样之后 SVM 才有能力对新数据进行分类。

  4. Apriori 关联算法
    Apriori算法学习数据的关联规则(association rules),适用于包含大量事务(transcation)的数据库。
    什么是关联规则
    关联规则学习是学习数据库中不同变量中的相互关系的一种数据挖掘技术。 举个 Apriori 算法的例子:我们假设有一个充满超市交易数据的数据库,你可以把数据库想象成一个巨大的电子数据表,表里每一行是一个顾客的交易情况,每一列代表不用的货物项。
    通过使用 Apriori 算法,我们就知道了同时被购买的货物项,这也叫做关联规则。它的强大之处在于,你能发现相比较其他货物来说,有一些货物更频繁的被同时购买—终极目的是让购物者买更多的东西。这些常被一起购买的货物项被称为项集(itemset)。
    如:“薯条+蘸酱”和“薯条+苏打水”的组合频繁的一起出现。这些组合被称为2-itemsets。在一个足够大的数据集中,就会很难“看到”这些关系了,尤其当还要处理3-itemset 或者更多项集的时候。这正是 Apriori 可以帮忙的地方!
    基本的 Apriori 算法有三步: 1.参与,扫描一遍整个数据库,计算1-itemsets 出现的频率。
    2.剪枝,满足支持度和可信度的这些1-itemsets移动到下一轮流程,再寻找出现的2-itemsets。
    3.重复,对于每种水平的项集 一直重复计算,知道我们之前定义的项集大小为止。
    Apriori 一般被认为是一种非监督的学习方法,因为它经常用来挖掘和发现有趣的模式和关系。

  5. EM 最大期望算法 Expectation Maximization
    在数据挖掘领域,最大期望算法(Expectation-Maximization,EM) 一般作为聚类算法(类似 kmeans 算法)用来知识挖掘。
    在统计学上,当估运算带有无法观测隐藏变量的统计模型参数时,EM 算法不断迭代和优化可以观测数据的似然估计值。
    统计模型?我把模型看做是描述观测数据是如何生成的。例如,一场考试的分数可能符合一种钟形曲线,因此这种分数分布符合钟形曲线(也称正态分布)的假设就是模型。
    什么是分布?分布代表了对所有可测量结果的可能性。例如,一场考试的分数可能符合一个正态分布。这个正态分布代表了分数的所有可能性。换句话说,给定一个分数,你可以用这个分布来预计多少考试参与者可能会得到这个分数。
    那么,你描述正态分布需要的所有东西就是这两个参数:
    1.平均值
    2.方差
    什么是似然性:
    回到我们之前的钟形曲线例子,假设我们已经拿到很多的分数数据,并被告知分数符合一个钟形曲线。然而,我们并没有给到所有的分数,只是拿到了一个样本。 可以这样做:
    我们不知道所有分数的平均值或者方差,但是我们可以使用样本计算它们。似然性就是用估计的方差和平均值得到的钟形曲线在算出很多分数的概率。
    换句话说,给定一系列可测定的结果,让我们来估算参数。再使用这些估算出的参数,得到结果的这个假设概率就被称为似然性。
    算法的优势是:对于数据挖掘和聚类,观察到遗失的数据的这类数据点对我们来说很重要。我们不知道具体的类,因此这样处理丢失数据对使用 EM 算法做聚类的任务来说是很关键的。 算法的精髓在于:
    通过优化似然性,EM 生成了一个很棒的模型,这个模型可以对数据点指定类型标签—听起来像是聚类算法!
    EM 算法是怎么帮助实现聚类的呢?EM 算法以对模型参数的猜测开始。然后接下来它会进行一个循环的3步:
    1.E 过程:基于模型参数,它会针对每个数据点计算对聚类的分配概率。
    2.M 过程:基于 E 过程的聚类分配,更新模型参数。
    3.重复知道模型参数和聚类分配工作稳定(也可以称为收敛)。
    EM 是非监督学习算法。 EM 算法的一个关键卖点就是它的实现直接。它不但可以优化模型参数,还可以反复的对丢失数据进行猜测。
    这使算法在聚类和产生带参数的模型上都表现出色。在得知聚类情况和模型参数的情况下,我们有可能解释清楚有相同属性的分类情况和新数据属于哪个类之中。
    EM算法弱点…
    第一,EM 算法在早期迭代中都运行速度很快,但是越后面的迭代速度越慢。
    第二,EM 算法并不能总是寻到最优参数,很容易陷入局部最优而不是找到全局最优解。

  6. PageRank算法 PageRank是为了决定一些对象和同网络中的其他对象之间的相对重要程度而设计的连接分析算法(link analysis algorithm)。
    什么是连接分析算法?
    它是一类针对网络的分析算法,探寻对象间的关系(也可成为连接)。
    举个例子:最流行的 PageRank 算法是 Google 的搜索引擎。尽管他们的搜索引擎不止是依靠它,但  PageRank依然是 Google 用来测算网页重要度的手段之一。
    万维网上的网页都是互相链接的。如果 Rayli.net 链接到了 CNN 上的一个网页,CNN 网页就增加一个投票,表示 rayli.net 和 CNN 网页是关联的。
    反过来,来自rayli.net 网页的投票重要性也要根据 rayli.net 网的重要性和关联性来权衡。换句话说,任何给 rayli.net 投票的网页也能提升 rayli.net 网页的关联性。
    概括一下:
    投票和关联性就是 PageRank 的概念。rayli.net 给CNN 投票增加了 CNN 的 Pagerank,rayli.net 的 PageRank级别同时也影响着它为 CNN 投票多大程度影响了CNN 的 PageRank。
    这排名有点像一个网页流行度的竞争。我们的头脑中都有了一些这些网站的流行度和关联度的信息。 PageRank只是一个特别讲究的方式来定义了这些而已。
    PageRank还有什么其他应用呢? PageRank是专门为了万维网设计的。
    可以考虑一下,以核心功能的角度看,PageRank算法真的只是一个处理链接分析极度有效率的方法。处理的被链接的对象不止只是针对网页。
    给出PageRank 的三个实现:
    1 C++ OpenSource PageRank Implementation
    2 Python PageRank Implementation
    3 igraph – The network analysis package (R)

  7. AdaBoost 迭代算法 AdaBoost 是个构建分类器的提升算法。
    分类器拿走大量数据,并试图预测或者分类新数据元素的属于的类别。 提升(boost) 指的什么?提升是个处理多个学习算法(比如决策树)并将他们合并联合起来的综合的学习算法。目的是将弱学习算法综合或形成一个组,把他们联合起来创造一个新的强学习器。
    强弱学习器之间有什么区别呢?弱学习分类器的准确性仅仅比猜测高一点。一个比较流行的弱分类器的例子就是只有一层的决策树。
    另一个,强学习分类器有更高的准确率,一个通用的强学习器的例子就是 SVM。
    举个 AdaBoost 算法的例子:我们开始有3个弱学习器,我们将在一个包含病人数据的数据训练集上对他们做10轮训练。数据集里包含了病人的医疗记录各个细节。
    问题来了,那我们怎么预测某个病人是否会得癌症呢?AdaBoost 是这样给出答案的:
    第一轮,AdaBoost 拿走一些训练数据,然后测试每个学习器的准确率。最后的结果就是我们找到最好的那个学习器。另外,误分类的样本学习器给予一个比较高的权重,这样他们在下轮就有很高的概率被选中了。
    再补充一下,最好的那个学习器也要给根据它的准确率赋予一个权重,并将它加入到联合学习器中(这样现在就只有一个分类器了)
    第二轮, AdaBoost 再次试图寻找最好的学习器。
    关键部分来了,病人数据样本的训练数据现在被有很高误分配率的权重影响着。换句话说,之前误分类的病人在这个样本里有很高的出现概率。
    为什么? 这就像是在电子游戏中已经打到了第二级,但当你的角色死亡后却不必从头开始。而是你从第二级开始然后集中注意,尽力升到第三级。
    同样地,第一个学习者有可能对一些病人的分类是正确的,与其再度试图对他们分类,不如集中注意尽力处理被误分类的病人。
    最好的学习器也被再次赋予权重并加入到联合分类器中,误分类的病人也被赋予权重,这样他们就有比较大的可能性再次被选中,我们会进行过滤和重复。
    在10轮结束的时候,我们剩下了一个带着不同权重的已经训练过的联合学习分类器,之后重复训练之前回合中被误分类的数据。
    算法灵活通用,AdaBoost 可以加入任何学习算法,并且它能处理多种数据。
    AdaBoost 有很多程序实现和变体。给出一些:
    ▪ scikit-learn
    ▪ ICSIBoost
    ▪ gbm: Generalized Boosted Regression Models

  8. kNN:k最近邻算法
    kNN,或 K 最近邻(k-Nearest Neighbors), 诗歌分类算法。然而,它和我们之前描述的分类器不同,因为它是个懒散学习法。
    懒散学习法? 和存储训练数据的算法不同,懒散学习法在训练过程中不需要做许多处理。只有当新的未被分类的数据输入时,这类算法才会去做分类。
    但在另一方面,积极学习法则会在训练中建立一个分类模型,当新的未分类数据输入时,这类学习器会把新数据也提供给这个分类模型。
    那么 C4.5,SVM 和 AdaBoost 属于哪类呢?不像 kNN算法,他们都是积极学习算法。
    给出原因:
    1 C4.5 在训练中建立了一个决策分类树模型。
    2 SVM在训练中建立了一个超平面的分类模型。
    3 AdaBoost在训练中建立了一个联合的分类模型。
    那么 kNN 做了什么? kNN 没有建立这样的分类模型,相反,它只是储存了一些分类好的训练数据。那么新的训练数据进入时,kNN 执行两个基本步骤:
    1 首先,它观察最近的已经分类的训练数据点—也就是,k最临近点(k-nearest neighbors)
    2 第二部,kNN使用新数据最近的邻近点的分类, 就对新数据分类得到了更好的结果了。
    你可能会怀疑…kNN 是怎么计算出最近的是什么? 对于连续数据来说,kNN 使用一个像欧氏距离的距离测度,距离测度的选择大多取决于数据类型。有的甚至会根据训练数据学习出一种距离测度。关于 kNN 距离测度有更多的细节讨论和论文描述。
    对于离散数据,解决方法是可以把离散数据转化为连续数据。给出两个例子:
    1 使用汉明距离(Hamming distance )作为两个字符串紧密程度的测度。
    2 把离散数据转化为二进制表征。
    当临近的点是不同的类,kNN 怎么给新数据分类呢?当临近点都是同一类的时候,kNN 也就不费力气了。我们用直觉考虑,如果附近点都一致,那么新数据点就很可能落入这同一个类中了。
    当临近点不是同一类时,kNN 怎么决定分类情况的呢?
    处理这种情况通常有两种办法:
    1 通过这些临近点做个简单的多数投票法。哪个类有更多的票,新数据就属于那个类。
    2 还是做个类似的投票,但是不同的是,要给那些离的更近的临近点更多的投票权重。这样做的一个简单方法是使用反距离(reciprocal distance). 比如,如果某个临近点距离5个单位,那么它的投票权重就是1/5.当临近点越来越远是,倒数距离就越来越小…这正是我们想要的。
    kNN 算法提供了已经被分类好的数据集,所以它是个监督学习算法。
    我们需要注意的5点:
    1 当试图在一个大数据集上计算最临近点时,kNN 算法可能会耗费高昂的计算成本。
    2 噪声数据(Noisy data)可能会影响到 kNN 的分类。
    3 选择大范围的属性筛选(feature)会比小范围的筛选占有很多优势,所以属性筛选(feature)的规模非常重要。
    4 由于数据处理会出现延迟,kNN 相比积极分类器,一般需要更强大的存储需求。
    5 选择一个合适的距离测度对 kNN 的准确性来说至关重要。
    哪里用过这个方法?有很多现存的 kNN 实现手段:
    ▪ MATLAB k-nearest neighbor classification
    ▪ scikit-learn KNeighborsClassifier
    ▪ k-Nearest Neighbour Classification in R

  9. Naive Bayes 朴素贝叶斯算法
    朴素贝叶斯(Naive Bayes)并不只是一个算法,而是一系列分类算法,这些算法以一个共同的假设为前提:
    被分类的数据的每个属性与在这个类中它其他的属性是独立的。
    独立是什么意思呢?当一个属性值对另一个属性值不产生任何影响时,就称这两个属性是独立的。 举个例子: 比如说你有一个病人的数据集,包含了病人的脉搏,胆固醇水平,体重,身高和邮编这样的属性。如果这些属性值互相不产生影响,那么所有属性都是独立的。对于这个数据集来说,假定病人的身高和邮编相互独立,这是合理的。因为病人的身高和他们的邮编没有任何关系。但是我们不能停在这,其他的属性间是独立的么?
    很遗憾,答案是否定的。给出三个并不独立的属性关系:
    ▪ 如果身高增加,体重可能会增加。
    ▪ 如果胆固醇水平增加,体重可能增加。
    ▪ 如果胆固醇水平增加,脉搏也可能会增加。
    以我的经验来看,数据集的属性一般都不是独立的。
    这样就和下面的问题联系起来了…
    为什么要把算法称为朴素的(naive)呢?数据集中所有属性都是独立的这个假设正是我们称为朴素(naive)的原因—— 通常下例子中的所有属性并不是独立的。
    我们在深入研究一下.. 这个等式是什么意思?在属性1和属性2的条件下,等式计算出了A 类的概率。换句话说,如果算出属性1 和2,等式算出的数据属于 A 类的概率大小。 等式这样写解释为:在属性1和属性2条件下,分类 A 的概率是一个分数。 ▪ 分数的分子是在分类 A条件下属性1的概率,乘以在分类 A 条件下属性2的概率,再乘以分类 A 的概率 ▪ 分数的分母是属性1的概率乘以属性2的概率。 Naive Bayes 的实现可以从Orange, scikit-learn, Weka和 R 里面找到。 最后,看一下第十种算法吧。
  10. CART 分类算法
    CART 代表分类和回归树(classification and regression trees)。它是个决策树学习方法,同时输出分类和回归树。 像 C4.5一样,CART 是个分类器。
    分类树像决策树一样么?分类树是决策树的一种。分类树的输出是一个类。
    举个例子,根据一个病人的数据集、你可能会试图预测下病人是否会得癌症。这个分类或者是“会的癌症”或者是“不会得癌症”。
    那回归树是什么呢?和分类树预测分类不同,回归树预测一个数字或者连续数值,比如一个病人的住院时间或者一部智能手机的价格。
    这么记比较简单:
    分类树输出类、回归树输出数字。
    为了构造分类和回归树模型,需要给它提供被分类好的训练数据集,因此 CART 是个监督学习算法。 为什么要使用 CART 呢?使用 C4.5的原因大部分也适用于 CART,因为它们都是决策树学习的方法。便于说明和解释这类的原因也适用于 CART。 和 C4.5一样,它们的计算速度都很快,算法也都比较通用流行,并且输出结果也具有可读性。 scikit-learn 在他们的决策树分类器部分实现了 CART 算法;R 语言的 tree package 也有 CART 的实现;Weka 和 MATLAB 也有CART的实现过程。

sqoop 特殊字符导入问题

Sqoop从MySQL导入数据到hive,示例:
sqoop import –connect jdbc:mysql://10.255.2.89:3306/test?charset=utf-8 – username selectuser –password select##select## –table test_sqoop_import \
–columns ‘id,content,updateTime’ \
–split-by id \
–hive-import –hive-table basic.test2;

如果不加其他参数,导入的数据默认的列分隔符是’\001’,默认的行分隔符是’\n’。
这样问题就来了,如果导入的数据中有’\n’,hive会认为一行已经结束,后面的数据被分割成下一行。这种情况下,导入之后hive中数据的行数就比原先数据库中的多,而且会出现数据不一致的情况。
Sqoop也指定了参数 –fields-terminated-by和 –lines-terminated-by来自定义行分隔符和列分隔符。
可是当你真的这么做时 坑爹呀
INFO hive.HiveImport: FAILED: SemanticException 1:381 LINES TERMINATED BY only supports newline ’\n’ right now.    也就是说虽然你通过–lines-terminated-by指定了其他的字符作为行分隔符,但是hive只支持’\n’作为行分隔符。
简单的解决办法就是加上参数–hive-drop-import-delims来把导入数据中包含的hive默认的分隔符去掉。

附 sqoop 命令参考

导入数据到 hdfs
使用 sqoop-import 命令可以从关系数据库导入数据到 hdfs。
$ sqoop import –connect jdbc:mysql://192.168.56.121:3306/metastore –username hiveuser –password redhat –table TBLS –target-dir /user/hive/result 注意:
mysql jdbc url 请使用 ip 地址
如果重复执行,会提示目录已经存在,可以手动删除
如果不指定 –target-dir,导入到用户家目录下的 TBLS 目录
你还可以指定其他的参数:

--append	将数据追加到hdfs中已经存在的dataset中。使用该参数,sqoop将把数据先导入到一个临时目录中,然后重新给文件命名到一个正式的目录中,以避免和该目录中已存在的文件重名。  
--as-avrodatafile	将数据导入到一个Avro数据文件中  
--as-sequencefile	将数据导入到一个sequence文件中  
--as-textfile	将数据导入到一个普通文本文件中,生成该文本文件后,可以在hive中通过sql语句查询出结果。  
--boundary-query <statement>	边界查询,也就是在导入前先通过SQL查询得到一个结果集,然后导入的数据就是该结果集内的数据,格式如:--boundary-query 'select id,no from t where id = 3',表示导入的数据为id=3的记录,或者 select min(<split-by>), max(<split-by>) from <table name>,注意查询的字段中不能有数据类型为字符串的字段,否则会报错
--columns<col,col>	指定要导入的字段值,格式如:--columns id,username
--direct	直接导入模式,使用的是关系数据库自带的导入导出工具。官网上是说这样导入会更快
--direct-split-size	在使用上面direct直接导入的基础上,对导入的流按字节数分块,特别是使用直连模式从PostgreSQL导入数据的时候,可以将一个到达设定大小的文件分为几个独立的文件。
--inline-lob-limit	设定大对象数据类型的最大值
-m,--num-mappers	启动N个map来并行导入数据,默认是4个,最好不要将数字设置为高于集群的节点数
--query,-e <sql>	从查询结果中导入数据,该参数使用时必须指定–target-dir、–hive-table,在查询语句中一定要有where条件且在where条件中需要包含 \$CONDITIONS,示例:--query 'select * from t where \$CONDITIONS ' --target-dir /tmp/t –hive-table t
--split-by <column>	表的列名,用来切分工作单元,一般后面跟主键ID
--table <table-name>	关系数据库表名,数据从该表中获取
--delete-target-dir	删除目标目录
--target-dir <dir>	指定hdfs路径
--warehouse-dir <dir>	与 --target-dir 不能同时使用,指定数据导入的存放目录,适用于hdfs导入,不适合导入hive目录
--where	从关系数据库导入数据时的查询条件,示例:--where "id = 2"
-z,--compress	压缩参数,默认情况下数据是没被压缩的,通过该参数可以使用gzip压缩算法对数据进行压缩,适用于SequenceFile, text文本文件, 和Avro文件
--compression-codec	Hadoop压缩编码,默认是gzip
--null-string <null-string>	可选参数,如果没有指定,则字符串null将被使用
--null-non-string <null-string>	可选参数,如果没有指定,则字符串null将被使用

使用 sql 语句
参照上表,使用 sql 语句查询时,需要指定 $CONDITIONS

$ sqoop import –connect jdbc:mysql://192.168.56.121:3306/metastore –username hiveuser –password redhat –query ‘SELECT * from TBLS where $CONDITIONS ‘ –split-by tbl_id -m 4 –target-dir /user/hive/result
上面命令通过 -m 1 控制并发的 map 数。

使用 direct 模式:
$ sqoop import –connect jdbc:mysql://192.168.56.121:3306/metastore –username hiveuser –password redhat –table TBLS –delete-target-dir –direct –default-character-set UTF-8 –target-dir /user/hive/result

指定文件输出格式:
$ sqoop import –connect jdbc:mysql://192.168.56.121:3306/metastore –username hiveuser –password redhat –table TBLS –fields-terminated-by “\t” –lines-terminated-by “\n” –delete-target-dir –target-dir /user/hive/result

指定空字符串:
$ sqoop import –connect jdbc:mysql://192.168.56.121:3306/metastore –username hiveuser –password redhat –table TBLS –fields-terminated-by “\t” –lines-terminated-by “\n” –delete-target-dir –null-string ‘\N’ –null-non-string ‘\N’ –target-dir /user/hive/result

如果需要指定压缩:
$ sqoop import –connect jdbc:mysql://192.168.56.121:3306/metastore –username hiveuser –password redhat –table TBLS –fields-terminated-by “\t” –lines-terminated-by “\n” –delete-target-dir –null-string ‘\N’ –null-non-string ‘\N’ –compression-codec “com.hadoop.compression.lzo.LzopCodec” –target-dir /user/hive/result

附:可选的文件参数如下表。

--enclosed-by <char>	给字段值前后加上指定的字符,比如双引号,示例:--enclosed-by '\"',显示例子:"3","jimsss","dd@dd.com"
--escaped-by <char>	给双引号作转义处理,如字段值为"测试",经过 --escaped-by "\\" 处理后,在hdfs中的显示值为:\"测试\",对单引号无效
--fields-terminated-by <char>	设定每个字段是以什么符号作为结束的,默认是逗号,也可以改为其它符号,如句号.,示例如:--fields-terminated-by
--lines-terminated-by <char>	设定每条记录行之间的分隔符,默认是换行串,但也可以设定自己所需要的字符串,示例如:--lines-terminated-by "#" 以#号分隔
--mysql-delimiters	Mysql默认的分隔符设置,字段之间以,隔开,行之间以换行\n隔开,默认转义符号是\,字段值以单引号'包含起来。
--optionally-enclosed-by <char>	enclosed-by是强制给每个字段值前后都加上指定的符号,而--optionally-enclosed-by只是给带有双引号或单引号的字段值加上指定的符号,故叫可选的

创建 hive 表
生成与关系数据库表的表结构对应的HIVE表:

$ sqoop create-hive-table --connect jdbc:mysql://192.168.56.121:3306/metastore --username hiveuser --password redhat --table TBLS 
--hive-home <dir>	Hive的安装目录,可以通过该参数覆盖掉默认的hive目录
--hive-overwrite	覆盖掉在hive表中已经存在的数据
--create-hive-table	默认是false,如果目标表已经存在了,那么创建任务会失败
--hive-table	后面接要创建的hive表
--table	指定关系数据库表名  导入数据到 hive   执行下面的命令会将 mysql 中的数据导入到 hdfs 中,然后创建一个hive 表,最后再将 hdfs 上的文件移动到 hive 表的目录下面。   $ sqoop import --connect jdbc:mysql://192.168.56.121:3306/metastore --username hiveuser --password redhat --table TBLS --fields-terminated-by "\t" --lines-terminated-by "\n" --hive-import --hive-overwrite --create-hive-table --hive-table dw_srclog.TBLS --delete-target-dir   说明:   可以在 hive 的表名前面指定数据库名称   可以通过 --create-hive-table 创建表,如果表已经存在则会执行失败   从上面可见,数据导入到 hive 中之后分隔符为默认分隔符,参考上文你可以通过设置参数指定其他的分隔符。   另外,Sqoop 默认地导入空值(NULL)为 null 字符串,而 hive 使用 \N 去标识空值(NULL),故你在 import 或者 export 时候,需要做相应的处理。在 import 时,使用如下命令:   $ sqoop import  ... --null-string '\\N' --null-non-string '\\N'   在导出时,使用下面命令:   $ sqoop import  ... --input-null-string '' --input-null-non-string ''

增量导入
–check-column (col) 用来作为判断的列名,如id
–incremental (mode) append:追加,比如对大于last-value指定的值之后的记录进行追加导入。lastmodified:最后的修改时间,追加last-value指定的日期之后的记录
–last-value (value) 指定自从上次导入后列的最大值(大于该指定的值),也可以自己设定某一值

合并 hdfs 文件
将HDFS中不同目录下面的数据合在一起,并存放在指定的目录中,示例如:
sqoop merge –new-data /test/p1/person –onto /test/p2/person –target-dir /test/merged –jar-file /opt/data/sqoop/person/Person.jar –class-name Person –merge-key id
其中,–class-name 所指定的 class 名是对应于 Person.jar 中的 Person 类,而 Person.jar 是通过 Codegen 生成的
–new-data Hdfs中存放数据的一个目录,该目录中的数据是希望在合并后能优先保留的,原则上一般是存放越新数据的目录就对应这个参数。 --onto Hdfs中存放数据的一个目录,该目录中的数据是希望在合并后能被更新数据替换掉的,原则上一般是存放越旧数据的目录就对应这个参数。 --merge-key <col> 合并键,一般是主键ID --jar-file 合并时引入的jar包,该jar包是通过Codegen工具生成的jar包 --class-name 对应的表名或对象名,该class类是包含在jar包中的。 --target-dir 合并后的数据在HDFS里的存放目录

hive 数据仓库优劣学习

#####Hive数据仓库优劣
Hive是一个基于Hadoop的数据仓库平台,通过Hive,可以方便地进行数据提取转化加载(ETL)的工作。Hive定义了一个类似于SQL的查询语言HQL,能够将用户编写的SQL转化为相应的MapReduce程序。当然,用户也可以自定义Mapper和Reducer来完成复杂的分析工作。
基于MapReduce的Hive具有良好的扩展性和容错性。不过由于MapReduce缺乏结构化数据分析中有价值的特性,以及Hive缺乏对执行计划的充分优化,导致Hive在很场景中执行效率不高。

强大的数据仓库和数据分析平台至少需要具备以下几点特性。
灵活的存储引擎
高效的执行引擎
良好的可扩展性
强大的容错机制
多样化的可视化

#######存储引擎 Hive数据存储没有特有的数据结构,(只是hdfs文件的映射)也没有为数据建立索引,可以自由地组织Hive中的表,只要在创建表时告诉Hive数据中的列分隔符和行分隔符,Hive就可以解析数据。Hive的元数据存储在RDBMS中,所有数据都基于HDFS存储。Hive包含Table、External Table、Partition和Bucket等数据模型。

#######执行引擎 Hive的编译器负责编译源代码并生成最终的执行计划,包括语法分析、语义分析、目标代码生成,所做的优化并不多。Hive基于MapReduce,Hive的Sort和GroupBy都依赖MapReduce。而MapReduce相当于固化了执行算子,Map的MergeSort必须执行,GroupBy算子也只有一种模式,Reduce的Merge-Sort也必须可选。另外Hive对Join算子的支持也较少。内存拷贝和数据预处理也会影响Hive的执行效率。
#######扩展性 Hive关注水平扩展性。简单来讲,水平扩展性指系统可以通过简单的增加资源来支持更大的数据量和负载。Hive处理的数据量是PB级的,而且每小时每天都在增长,这就使得水平扩展性成为一个非常重要的指标。Hadoop系统的水平扩展性是非常好的,而Hive基MapReduce框架,因此能够很自然地利用这点。 #######容错性 Hive有较好的容错性。Hive的执行计划在MapReduce框架上以作业的方式执行,每个作业的中间结果文件写到本地磁盘,最终输出文件写到HDFS文件系统,利用HDFS的多副本机制来保证数据的可靠性,从而达到作业的容错性。如果在作业执行过程中某节点出现故障,那么Hive执行计划基本不会受到影响。因此,基于Hive实现的数据仓库可以部署在由普通机器构建的分布式集群之上。 #######可视化 Hive的可视化界面基本属于字符终端,用户的技术水平一般比较高。面向不同的应用和用户,提供个性化的可视化展现,是Hive改进的一个重要方向。

MR中Join方案

####MR中Join方案 与传统数据一样在MR中的join操作也是一项耗时的操作,但是我们可以根据MR 的设计思想对其进行优化。
#######Reduce side join
这是最简单的一种形式,主要思想:
在map阶段,map函数同时读取两个文件File1和File2,为了区分两种来源的key/value数据对,对每条数据打一个标签(tag),比如:tag=0表示来自文件File1,tag=2表示来自文件File2。即:map阶段的主要任务是对不同文件中的数据打标签。
在reduce阶段,reduce函数获取key相同的来自File1和File2文件的value list, 然后对于同一个key,对File1和File2中的数据进行join(笛卡尔乘积)。即:reduce阶段进行实际的连接操作。这种形式主要是利用hadoop mr 的框架机制。

#######Map side join
reduce side join,是因为在map阶段不能获取所有需要的join字段,即:同一个key对应的字段可能位于不同map中。Reduce side join是非常低效的,因为shuffle阶段要进行大量的数据传输。
Map side join是针对以下场景进行的优化:两个待连接表中,有一个表非常大,而另一个表非常小,以至于小表可以直接存放到内存中。这样,我们可以将小表复制多份,让每个map task内存中存在一份(比如存放到hash table中),然后只扫描大表:对于大表中的每一条记录key/value,在hash table中查找是否有相同的key的记录,如果有,则连接后输出即可。
为了支持文件的复制,
Hadoop提供了一个类DistributedCache,使用该类的方法如下:
(1)用户使用静态方法DistributedCache.addCacheFile(URI)指定要复制的文件。JobTracker在作业启动之前会获取这个URI列表,并将相应的文件拷贝到各个TaskTracker的本地磁盘上。
(2)用户使用DistributedCache.getLocalCacheFiles()方法获取文件目录,并使用标准的文件读写API读取相应的文件。
如果足够小 也可以 放在context里面(不推荐)
#######Semi Join
Semi Join,也叫半连接,是从分布式数据库中借鉴过来的方法。它的产生动机是:对于reduce side join,跨机器的数据传输量非常大,这成了join操作的一个瓶颈,如果能够在map端过滤掉不会参加join操作的数据,则可以大大节省网络IO。
实现方法很简单:选取一个小表,假设是File1,将其参与join的key抽取出来,保存到文件File3中,File3文件一般很小,可以放到内存中。在map阶段,使用DistributedCache将File3复制到各个TaskTracker上,然后将File2中不在File3中的key对应的记录过滤掉,剩下的reduce阶段的工作与reduce side join相同。
#######reduce side join + BloomFilter
在某些情况下,SemiJoin抽取出来的小表的key集合在内存中仍然存放不下,这时候可以使用BloomFiler以节省空间。
BloomFilter最常见的作用是:判断某个元素是否在一个集合里面。它最重要的两个方法是:add() 和contains()。最大的特点是不会存在 false negative,即:如果contains()返回false,则该元素一定不在集合中,但会存在一定的 false positive,即:如果contains()返回true,则该元素一定可能在集合中。因而可将小表中的key保存到BloomFilter中,在map阶段过滤大表,可能有一些不在小表中的记录没有过滤掉(但是在小表中的记录一定不会过滤掉),这没关系,只不过增加了少量的网络IO而已。
#######二次排序 在Hadoop中,默认情况下是按照key进行排序,如果要按照value进行排序怎么办?即:对于同一个key,reduce函数接收到的value list是按照value排序的。这种应用需求在join操作中很常见,比如,希望相同的key中,小表对应的value排在前面。
有两种方法进行二次排序,分别为:buffer and in memory sort和 value-to-key conversion。 对于buffer and in memory sort,主要思想是:在reduce()函数中,将某个key对应的所有value保存下来,然后进行排序。 这种方法最大的缺点是:可能会造成out of memory。
对于value-to-key conversion,主要思想是:将key和部分value拼接成一个组合key(实现WritableComparable接口或者调用setSortComparatorClass函数),这样reduce获取的结果便是先按key排序,后按value排序的结果,需要注意的是,用户需要自己实现Paritioner,以便只按照key进行数据划分。
Hadoop显式的支持二次排序,在Configuration类中有个setGroupingComparatorClass()方法,可用于设置排序group的key值 实际工作多数情况下,会采用第一种,reduce side join 简单 安全 。。。。

DB演进理解

##DB演进理解

  1. RDBMS
    这是最熟悉的数据存储方式,一般情况下数据存储在一台机器上,这种形式方便提供完善ACID特性和丰富查询模型。这就是传统的关系型数据库的基础模式,但是面对现如今越来越大的数据量,这种模式的扩展变得难以满足。实践证明通过增加节点这种简单廉价的扩展方式是可行的。RDBMS的横向扩展主要有主从复制(Master-slave)、分表、分区等。
    横向扩展RDBMS – Master/Slave 
    利用数据库的复制或镜像功能,同时在多台数据库上保存相同的数据,从而将读操作和写操作分开,写操作集中在一台主数据库上,读操作集中在多台从数据库上。
    问题:
    读写同步需要一定的时间,导致关键的读取有出错风险;
    主节点将数据复制到从节点,数据量很大是可能造成问题,

    横向扩展RDBMS - Sharding
    在满足ACID特性的数据库中进行扩展是非常难的。基于这个原因,对数据进行扩展,这个数据库本身就必须拥有简单的模型,将数据分割为N片,然后在单独的片中执行查询。数据分割的单元被称为“shard”。将N片数据分配个M个DBMS进行操作。DBMS并不会去管理数据片,程序开发负责数据片的处理。 不同的分片方法有:

    • 垂直分区(Vertical Partitioning):将不需要进行联合查询的数据表分散到不同的数据库服务器上。
    • 水平分区(sharding) 将同一个表的记录拆分到不同的表甚至是服务器上,这往往需要一个稳定的算法来保证读取时能正确从不同的服务器上取得数据。如Range-Based Partitioning, Key or Hash-Based partitioning等。
      优点与不足
    • 对读取和写入都有很好的扩展
    • 不透明,程序需要识别分区 
    • 不再有跨分区的关系/joins 
    • 参照完整性损失

    其他RDBMS扩展方法
    Multi-Master replication:所有成员都响应客户端数据查询。多主复制系统负责将任意成员做出的数据更新传播给组内其他成员,并解决不同成员间并发修改可能带来的冲突。
    INSERT only, not UPDATES/DELETES:数据进行版本化处理。
    No JOINs, thereby reducing query time:Join的开销很大,而且频繁访问会使开销随着时间逐渐增加。
    非规范化(Denormalization)可以降低数据仓库的复杂性,以提高效率和改善性能。
    In-memory databases:磁盘数据库解决的是大容量存储和数据分析问题,内存数据库解决的是实时处理和高并发问题。主流常规的RDBMS更多的是磁盘密集型,而不是内存密集型。

    ACID Transactions
    一个完善的数据库系统都是希望支持“ACID transactions,”其包括:
    Atomic : Either the whole process is done or none is.(原子性)
    Consistent : Database constraints are preserved.(一致性)
    Isolated : It appears to the user as if only one process executes at a time.(隔离性)
    Durable : Effects of a process do not get lost if the system crashes.(持久性)

  2. NoSQL

NoSQL现在被理解为 Not Only SQL 的缩写,是对非关系型的数据库管理系统的统称 NoSQL 与 RDBMS 不同点,
-不使用SQL作为查询语言。
-不需要固定的表模式(table schema)。

  • 放宽一个或多个 ACID 属性(CAP定理)

补充:CAP理论
CAP理论是数据系统设计的基本理论,目前几乎所有的数据系统的设计都遵循了这个理论。CAP理论指出,分布式系统只能满足以下三项中的两项而不可能满足全部三项,
一致性(Consistency)(所有节点在同一时间具有相同的数据)
可用性(Availability)(保证每个请求不管成功或者失败都有响应)
分区容忍性(Partition tolerance)(系统中任意信息的丢失或失败不会影响系统的继续运作)

一致性有两种类型:

  • strong consistency – ACID(Atomicity Consistency Isolation Durability):对于关系型数据库,要求更新过的数据能被后续所有的访问都看到,这是强一致性。
  • weak consistency – BASE(Basically Available Soft-state Eventual consistency ) – Basically Available - system seems to work all the time (基本可用)
    – Soft State - it doesn’t have to be consistent all the time (不要求所有时间都一致)
    – Eventually Consistent - becomes consistent at some later time (最终一致性)

对于分布式数据系统(scale out),分区容忍性是基本要求,否则就失去了价值。因此只能在一致性和可用性上做取舍,如何处理这种取舍正是目前NoSQL数据库的核心焦点。牺牲一致性而换取高可用性。当然,牺牲一致性,只是不再要求关系数据库中的强一致性,而是只要系统能达到最终一致性即可。通常是通过数据的多份异步复制来实现系统的高可用和数据的最终一致性的。

NoSQL 的两种主要实现方式
1.Key/Value
Amazon S3 (Dynamo)
Voldemort
Scalaris
Memcached (in-memory key/value store)
Redis

  1. 弱模式型(column-based, document-based or graph-based.)
    Cassandra (column-based)
    CouchDB (document-based)
    MongoDB(document-based)
    Neo4J (graph-based)
    HBase (column-based)

K/V模式
优点:
very fast
very scalable
simple model
able to distribute horizontally
劣势:
many data structures (objects) can’t be easily modeled as key value pairs (需要多余转换)
Schema-Less 模式
优点
Schema-less data model is richer than key/value pairs eventual consistency
many are distributed
still provide excellent performance and scalability
劣势
typically no ACID transactions or joins

  1. HBase

HBase is an open-source, distributed, column-oriented database built on top of HDFS (or KFS) based on BigTable! 
按照CAP理论,HBase属于C+P类型的系统。HBase是强一致性的(仅支持单行事务)。每一行由单个区域服务器(region server)host,行锁(row locks)和多版本并发控制(multiversion concurrency control)的组合被用来保证行的一致性。
查找:
快速定位使用row key + column family + column + timestamp.
按范围查找:start row key – end row key.
全表扫描
交互方式

  • Java, REST, or Thrift APIs.
  • Scripting via JRuby.

HBase 一些特性

- No real indexes(row key 即数据的索引)  
- Automatic partitioning(region自动split)  
- Scale linearly and automatically with new nodes(扩展容易 节点添加方便)  
- Commodity hardware(廉价硬件)  
- Fault tolerance(较强的容错性)  
- Batch processing(批处理能力优秀)  
  1. Hive

    • Provide higher-level language (HQL, like SQL) to facilitate large-data processing
    • Higher-level language “compiles down” to Hadoop Map/Reduce jobs
  2. Hive + HBase

    Reasons to use Hive on HBase:
    A lot of data sitting in HBase due to its usage in a real-time environment, but never used for analysis
    Give access to data in HBase usually only queried through MapReduce to people that don’t code (business analysts)
    When needing a more flexible storage solution, so that rows can be updated live by either a Hive job or an application and can be seen immediately to the other

CDH 安装问题

CDH5安装参照:http://www.tuicool.com/articles/ENjmeaY
Q1:安装过程中提示找不到MySQL 驱动jar包
:在/usr/shar/java 中添加mysql-connector-java-5.1.30-bin.jar
Q2:安装hive提示找不到MySQL驱动jar包
:在/opt/cloudera/parcels/CDH-5.1.3-1.cdh5.1.3.p0.12/lib/hive/lib/ 中添加 mysql-connector-java-5.1.30-bin.jar
Q3: cloudera-server 或cloudera-agent status 提示服务已经停止,pid仍然存在
:查看对应的log 可能是端口占用或是数据库连接问题
Q4:MR2和HDFS安装好后 web ui无法访问,查看对应端口已经处于listen状态,
:分别在对应的配置中的端口和地址选项中将“将 ResourceManager 绑定到通配符地址”项, 勾选上
没有这个选项的可以在高级设置中在XML文件中添加
Q5:jdk版本不对应
: CDH默认获取的jdk 位于:/usr/java 可将需要的jdk 拷贝到这个目录中。

Q6 sqoop导入数据时:User does not belong to hive
I had same issue with permissions -> chgrp: changing ownership of ‘/user/hive/warehouse/test/_log24310.txt’: User does not belong to hive. 1.Added the existing user named cloudera to existing group named hive with command: usermod -a -G hive cloudera 2.Restarted the system 3.Used Load Command and after that did a select * from table_name -> No data was getting displayed. 4.Executed select count(*) from table_name and a MapReduce job got started. 5.Executed select * from table and now results was returned correctly. 6.Opened a impala shell using impala-shell command. 7.Executed a select * from table_name and no results was getting returned. 8.Executed command invalidate metadata in the impala-shell 9.Executed command refresh table_name 10.Executed command show tables 11.Executed command select * from table_name and now results are getting displayed both in the impala-shell and hive shell. 可以不必理会

Q6:spark 安装不上
未解决,网上有对应bug

整个安装过程中遇到各种问题,主要解决得途径还是查看对应的log文件对应解决:
/var/log/hadoop*
/var/log/cloudera*
/opt/cm-5.1.3/log

######===========================about================================================================================================================================== 问题导读

1.CM的安装目录在什么位置?  
2.hadoop配置文件在什么位置?  
3.Cloudera manager运行所需要的信息存在什么位置?  
4.CM结构和功能是什么?  
1. 相关目录  
/var/log/cloudera-scm-installer : 安装日志目录。  
/var/log/* : 相关日志文件(相关服务的及CM的)。  
/usr/share/cmf/ : 程序安装目录。  
/usr/lib64/cmf/ : Agent程序代码。  
/var/lib/cloudera-scm-server-db/data : 内嵌数据库目录。  
/usr/bin/postgres : 内嵌数据库程序。  
/etc/cloudera-scm-agent/ : agent的配置目录。  
/etc/cloudera-scm-server/ : server的配置目录。  
/opt/cloudera/parcels/ : Hadoop相关服务安装目录。  
/opt/cloudera/parcel-repo/ : 下载的服务软件包数据,数据格式为parcels。  
/opt/cloudera/parcel-cache/ : 下载的服务软件包缓存数据。  
/etc/hadoop/* : 客户端配置文件目录。  
  1. 配置

Hadoop配置文件
配置文件放置于/var/run/cloudera-scm-agent/process/目录下。如:/var/run/cloudera-scm-agent/process/193-hdfs-NAMENODE/core-site.xml。这些配置文件是通过Cloudera Manager启动相应服务(如HDFS)时生成的,内容从数据库中获得(即通过界面配置的参数)。
在CM界面上更改配置是不会立即反映到配置文件中,这些信息会存储于数据库中,等下次重启服务时才会生成配置文件。且每次启动时都会产生新的配置文件。
CM Server主要数据库为scm基中放置配置的数据表为configs。里面包含了服务的配置信息,每一次配置的更改会把当前页面的所有配置内容添加到数据库中,以此保存配置修改历史。
scm数据库被配置成只能从localhost访问,如果需要从外部连接此数据库,修改vim /var/lib/cloudera-scm-server-db/data/pg_hba.conf文件,之后重启数据库。运行数据库的用户为cloudera-scm。

查看配置内容
1.直接查询scm数据库的configs数据表的内容。
2.访问REST API: http://hostname:7180/api/v4/cm/deployment,返回JSON格式部署配置信息。

配置生成方式
CM为每个服务进程生成独立的配置目录(文件)。所有配置统一在服务端查询数据库生成(因为scm数据库只能在localhost下访问)生成配置文件,再由agent通过网络下载包含配置文件的zip包到本地解压到指定的目录。

配置修改
CM对于需要修改的配置预先定义,对于没有预先定义的配置,则通过在高级配置项中使用xml配置片段的方式进行配置。而对于/etc/hadoop/下的配置文件是客户端的配置,可以在CM通过部署客户端生成客户端配置。

  1. 数据库
    Cloudera manager主要的数据库为scm,存储Cloudera manager运行所需要的信息:配置,主机,用户等。
  2. CM结构

CM分为Server与Agent两部分及数据库(自带更改过的嵌入Postgresql)。它主要做三件事件:

1.管理监控集群主机。
2.统一管理配置。
3.管理维护Hadoop平台系统。
实现采用C/S结构,Agent为客户端负责执行服务端发来的命令,执行方式一般为使用python调用相应的服务shell脚本。Server端为Java REST服务,提供REST API,Web管理端通过REST API调用Server端功能,Web界面使用富客户端技术(Knockout)。
1.Server端主体使用Java实现。
2.Agent端主体使用Python, 服务的启动通过调用相应的shell脚本进行启动,如果启动失败会重复4次调用启动脚本。
3.Agent与Server保持心跳,使用Thrift RPC框架。
  1. 升级

在CM中可以通过界面向导升级相关服务。升级过程为三步:

1.下载服务软件包。
2.把所下载的服务软件包分发到集群中受管的机器上。
3.安装服务软件包,使用软链接的方式把服务程序目录链接到新安装的软件包目录上。
  1. 卸载

sudo /usr/share/cmf/uninstall-scm-express.sh, 然后删除/var/lib/cloudera-scm-server-db/目录,不然下次安装可能不成功。

  1. 开启postgresql远程访问

    CM内嵌数据库被配置成只能从localhost访问,如果需要从外部查看数据,数据修改vim /var/lib/cloudera-scm-server-db/data/pg_hba.conf文件,之后重启数据库。运行数据库的用户为cloudera-scm。