天道酬勤 李辉的博客 | 关注大数据相关技术及开源项目
Finding association rules with Mahout Frequent Pattern Mining
Mahout 频繁模式挖掘生成 关联规则
is a method to find relations between variables in a database. For instance, using shopping receipts, we can find association between items: bread is often purchased with peanut butter or chips and beer are often bought together. In this post, we are going to use the
implementation to find the associations between items using a list of shopping transactions. For details on the algorithms(apriori and fpgrowth) used to find frequent patterns, you can look at
from Deepti Pawar.
EDIT : updated link to data sample marketbasket.csv (old link was dead). Corrected lift computation. Thanks Felipe F. for pointing the error in the formula.
（关联规则学习）是一种用于发现数据库中变量之间关系的方法。例如，通过购物清单，我们可以发现商品之间的关联性：面包或啤酒通常与花生酱或薯片一起购买。在这篇文章中，我们通过一个购物交易清单使用Mahout频繁模式挖掘的实现 发现 其中商品的关联性。用于发现频繁模式算法(apriori 和 fpgrowth)的更多细节，参考Deepti Pawar
EDIT :更新了数据样例的链接marketbasket.csv (旧链接失效)。Corrected lift computation.。感谢Felipe F.
指出公式中的错误。
Requirement基本要求
For this tutorial, you would need: 本教程的运行需求
jdk &= 1.6
hadoop (preferably 1.1.1)
mahout &= 0.7
To install hadoop and mahout, you can follow the steps described on a previous
that shows how to use the mahout recommender.
When you are done installing hadoop and mahout, make sure you set them in your PATH so you can easily call them:
安装hadoop 和 mahout，你可以参考之前的帖子：如何使用mahout 推荐，当两者安装后，确保对他们设置环境变量以方便调用。
export PATH=$PATH:[HADOOP_DIR]/bin:$PATH:[MAHOUT_DIR]/bin
You can get the sourcecode used in this tutorial from the : 获取本教程的源代码:
$ git clone /fredang/mahout-frequent-pattern-mining-example.git
To compile the project: 编译项目
$ mvn clean package assembly:single
For this post, we are using a data set of transactions from a grocery store. You can download the file from . The CSV contains data in the following format:
本文中，我们使用一个杂货店的交易数据集。下载地址为 来自
的。数据集数据格式如下：
Hair Conditioner
Standard coffee
Frozen Chicken Wings
Fat Free Hamburger
Sugar Cookie
Each line represents a customer basket. For instance in the first transaction, the customer bought a coffee and a sugar cookie. To use the mahout frequent pattern mining, we need to convert this data into the following format:
每行数据表示一个 顾客购物篮。例如，第一个交易，客户购买了一盒咖啡和一盒曲奇饼干。使用mahout 频繁模式挖掘，我们需要将数据转化为如下格式：
[item id1], [item id2], [item id3]
0, 2, 6, …
0, 1, 6, …
4, 5, …
Code to convert the csv to dat file:
csv转化为dat文件的代码
public class ConvertCsvToDat {
public static void main(String args[]) throws Exception {
if (args.length != 1) {
System.err.println(“Arguments: [marketbasket.csv path]“);
String csvFilename = args[0];
BufferedReader csvReader = new BufferedReader(new FileReader(csvFilename));
// with the first line we can get the mapping id, text
String line = csvReader.readLine();
String[] tokens = line.split(“,”);
FileWriter mappingWriter = new FileWriter(“mapping.csv”);
int i = 0;
for(String token: tokens) {
mappingWriter.write(token.trim() + “,” + i + “\n”);
mappingWriter.close();
FileWriter datWriter = new FileWriter(“output.dat”);
int transactionCount = 0;
while(true) {
line = csvReader.readLine();
if (line == null) {
tokens = line.split(“,”);
boolean isFirstElement =
for(String token: tokens) {
if (token.trim().equals(“true”)) {
if (isFirstElement) {
isFirstElement =
datWriter.append(“,”);
datWriter.append(Integer.toString(i));
datWriter.append(“\n”);
transactionCount++;
datWriter.close();
System.out.println(“Wrote ” + transactionCount + ” transactions.”);
To run the program: 运行代码
$ java -cp target/mahout-frequent-pattern-mining-example-1.0-jar-with-dependencies.jar com.chimpler.example.fpm.ConvertCsvToDat [marketbasket.csv path]
Wrote 1361 transactions.
This program creates two files: 本程序创建两个文件
output.dat: contains the transaction data in the new format 包含交易数据的新格式文件
mapping.csv: contains the mapping between the item name and the item id：包含商品名称和商品id的映射文件。
To run the Mahout frequent pattern mining, we need first to copy the file output.dat to HDFS:
运行Mahout频繁模式挖掘之前，我们需要把output.dat文件上传到HDFS:
$ hadoop fs -put output.dat output.dat
Now we can run mahout: 现在，运行mahout
$ mahout fpg -i output.dat -o patterns -k 10 -method mapreduce -s 2
The options: 参数选项
-k 10 means that for each item i, we find the top 10 association rules: the sets of items including the item i which occurs in the biggest number of transactions.
意味着对于每个商品I, 我们找出前十个关联规则：
-s 2 means that we only consider the sets of items which appears in more than 2 transactions
It generates several files/directories in the patterns directory:
fList: sequence file which associates to an item the number of transactions containing that word
frequentpatterns: sequence file which contains for each item the
parallelcounting
We can look at the raw result:
$ mahout seqdumper -i patterns/frequentpatterns/part-r-00000
13/04/30 20:51:42 INFO common.AbstractJob: Command line arguments: {–endPhase=[], –input=[patterns/frequentpatterns/part-r-00000], –startPhase=[0], –tempDir=[temp]}
Input Path: patterns/frequentpatterns/part-r-00000
Key class: class org.apache.hadoop.io.Text Value Class: class org.apache.mahout.fpm.pfpgrowth.convertors.string.TopKStringPatterns
Key: 0: Value: ([0],80), ([141, 0],42), ([132, 0],42), ([124, 0],39), ([132, 141, 0],30), ([141, 124, 0],29), ([132, 124, 0],29), ([132, 141, 124, 0],22), ([132, 141, 153, 0],20), ([132, 141, 124, 153, 0],15)
Key: 1: Value: ([1],41), ([141, 1],25), ([132, 1],25), ([16, 1],24), ([141, 16, 1],20), ([132, 141, 1],20), ([132, 16, 1],18), ([16, 175, 1],17), ([132, 141, 16, 1],16), ([132, 141, 16, 175, 1],13)
Key: 10: Value: ([10],13), ([6, 10],8), ([126, 10],7), ([124, 10],7), ([110, 10],7), ([6, 126, 10],6), ([110, 6, 10],6), ([110, 6, 126, 10],5), ([124, 126, 10],5), ([124, 110, 6, 126, 10],4)
Key: 100: Value: ([100],43), ([141, 100],28), ([132, 100],26), ([124, 100],25), ([132, 141, 100],21), ([141, 124, 100],20), ([132, 124, 100],19), ([132, 141, 124, 100],16), ([132, 141, 252, 100],15), ([132, 141, 124, 252, 100],12)
Key: 101: Value: ([101],40), ([141, 101],23), ([132, 101],23), ([124, 101],23), ([132, 141, 101],17), ([141, 124, 101],16), ([132, 124, 101],15), ([132, 141, 16, 101],13), ([132, 141, 124, 101],11), ([132, 141, 124, 16, 101],10)
Key: 102: Value: ([102],9), ([121, 102],8), ([238, 121, 102],6), ([141, 121, 102],6), ([124, 102],6), ([141, 238, 121, 102],5), ([124, 121, 102],5), ([141, 124, 238, 121, 102],4), ([124, 217, 121, 102],4), ([141, 124, 238, 217, 121, 102],3)
The first line shows the top 10 associations with the item 0. ([0],80) means that the item 0 appears in 80 transactions. ([141, 0],42) means that the pair item 141 and item 0 appears in 42 transactions and so on. The association rules can be measured using several metrics:
is the proportion of transactions containing the set X:
confidence
is the proportion of transaction containing X which also contains Y:
lift is the ratio of the observed support to that expected if X and Y were independent:
conviction can be interpreted as the ratio of the expected frequency that X occurs without Y:
We can copy the files fList and frequentpatterns from HDFS to the local filesystem to analyze the data:
$ hadoop fs -getmerge patterns/frequentpatterns frequentpatterns.seq
$ hadoop fs -get patterns/fList fList.seq
We wrote a program to read the data generated by the mahout pattern mining and show the value of the metrics for each frequent patterns.
我们编写一个程序
public class ResultReader {
public static Map&Integer, Long& readFrequency(Configuration configuration, String fileName) throws Exception {
FileSystem fs = FileSystem.get(configuration);
Reader frequencyReader = new SequenceFile.Reader(fs,
new Path(fileName), configuration);
Map&Integer, Long& frequency = new HashMap&Integer, Long&();
Text key = new Text();
LongWritable value = new LongWritable();
while(frequencyReader.next(key, value)) {
frequency.put(Integer.parseInt(key.toString()), value.get());
public static Map&Integer, String& readMapping(String fileName) throws Exception {
Map&Integer, String& itemById = new HashMap&Integer, String&();
BufferedReader csvReader = new BufferedReader(new FileReader(fileName));
while(true) {
String line = csvReader.readLine();
if (line == null) {
String[] tokens = line.split(“,”, 2);
itemById.put(Integer.parseInt(tokens[1]), tokens[0]);
return itemById;
public static void readFrequentPatterns(
Configuration configuration,
String fileName,
int transactionCount,
Map&Integer, Long& frequency,
Map&Integer, String& itemById,
double minSupport, double minConfidence) throws Exception {
FileSystem fs = FileSystem.get(configuration);
Reader frequentPatternsReader = new SequenceFile.Reader(fs,
new Path(fileName), configuration);
Text key = new Text();
TopKStringPatterns value = new TopKStringPatterns();
while(frequentPatternsReader.next(key, value)) {
long firstFrequencyItem = -1;
String firstItemId =
List&Pair&List, Long&& patterns = value.getPatterns();
int i = 0;
for(Pair&List, Long& pair: patterns) {
List itemList = pair.getFirst();
Long occurrence = pair.getSecond();
if (i == 0) {
firstFrequencyItem =
firstItemId = itemList.get(0);
double support = (double)occurrence / transactionC
double confidence = (double)occurrence / firstFrequencyI
if (support & minSupport
&& confidence & minConfidence) {
List listWithoutFirstItem = new ArrayList();
for(String itemId: itemList) {
if (!itemId.equals(firstItemId)) {
listWithoutFirstItem.add(itemById.get(Integer.parseInt(itemId)));
String firstItem = itemById.get(Integer.parseInt(firstItemId));
listWithoutFirstItem.remove(firstItemId);
System.out.printf(
“%s =& %s: supp=%.3f, conf=%.3f”,
listWithoutFirstItem,
firstItem,
confidence);
if (itemList.size() == 2) {
// we can easily compute the lift and the conviction for set of
// size 2, so do it
int otherItemId = -1;
for(String itemId: itemList) {
if (!itemId.equals(firstItemId)) {
otherItemId = Integer.parseInt(itemId);
long otherItemOccurrence = frequency.get(otherItemId);
double lift = ((double)occurrence * transactionCount) / (firstFrequencyItem * otherItemOccurrence);
double conviction = (1.0 – (double)otherItemOccurrence / transactionCount) / (1.0 – confidence);
System.out.printf(
“, lift=%.3f, conviction=%.3f”,
lift, conviction);
System.out.printf(“\n”);
frequentPatternsReader.close();
public static void main(String args[]) throws Exception {
if (args.length != 6) {
System.err.println(“Arguments: [transaction count] [mapping.csv path] [fList path] “
+ “[frequentPatterns path] [minSupport] [minConfidence]“);
int transactionCount = Integer.parseInt(args[0]);
String mappingCsvFilename = args[1];
String frequencyFilename = args[2];
String frequentPatternsFilename = args[3];
double minSupport = Double.parseDouble(args[4]);
double minConfidence = Double.parseDouble(args[5]);
Map&Integer, String& itemById = readMapping(mappingCsvFilename);
Configuration configuration = new Configuration();
Map&Integer, Long& frequency = readFrequency(configuration, frequencyFilename);
readFrequentPatterns(configuration, frequentPatternsFilename,
transactionCount, frequency, itemById, minSupport, minConfidence);
To run the program: 运行程序
$ java -cp target/mahout-frequent-pattern-mining-example-1.0-jar-with-dependencies.jar com.chimpler.example.fpm.ResultReader 1361 mapping.csv fList.seq frequentpatterns.seq 0.04 0.4
The arguments of this program are: 本程序参数为：
transaction count 交易数据总数
the file containing the mapping item =& item id
商品名称与商品id映射文件
fList.seq a sequence file containing for each item id, the number of transactions containing that word
frequentpatterns.seq the frequent patterns sequence file computed by mahout
mahout 计算出的 频繁模式序列文件。
mininum support
最小支持度
minimum confidence 最小置信度
To find the minimum support and minimum confidence to use, try using different values until you get relevant results. The program shows the following associations:
[Sweet Relish] =& Hot Dogs: supp=0.047, conf=0.508, lift=5.959, conviction=1.859
[Eggs] =& Hot Dogs: supp=0.043, conf=0.460, lift=3.751, conviction=1.626
[Hot Dog Buns] =& Hot Dogs: supp=0.042, conf=0.452, lift=7.696, conviction=1.719
[White Bread] =& Hot Dogs: supp=0.040, conf=0.437, lift=3.667, conviction=1.563
[Eggs] =& 2pct. Milk: supp=0.052, conf=0.477, lift=3.883, conviction=1.676
[White Bread] =& 2pct. Milk: supp=0.051, conf=0.470, lift=3.947, conviction=1.662
[Potato Chips] =& 2pct. Milk: supp=0.045, conf=0.409, lift=4.189, conviction=1.528
[White Bread] =& Tomatoes: supp=0.040, conf=0.611, lift=5.134, conviction=2.265
[White Bread] =& Eggs: supp=0.055, conf=0.449, lift=3.773, conviction=1.599
[2pct. Milk] =& Eggs: supp=0.052, conf=0.425, lift=3.883, conviction=1.549
The association rules are making sense: clients buying “Sweet Relish”, “Eggs”, “Hot Dog Buns” or “White Bread” are also buying “Hot Dogs”.
In this tutorial we showed how to use the mahout pattern frequent mining implementation on a grocery store transactions to find items that are often purchased together. This algorithm can be used in various other domains, for instance to find association rules in gene expressions or in population census,
关联规则是有意义的：客户购买“Sweet Relish”, “Eggs”, “Hot Dog Buns” 或 “White Bread” 同时也购买 “Hot Dogs”。
本教程中 我们通过一个杂货店交易数据 使用mahout频繁模式挖掘实现 来发现 经常一起购买的商品。该算法可应用于其他领域，例如在基因表达和人口普查中寻找关联规则。
本条目发布于。属于分类。作者是。
将你的任务分割为map 和 reduce
选择适当的task数量可以从根本上优化Hadoop的性能。增加task 的数量会增加框架的开销，但同时也会增强负载均衡并降低任务失败的开销。一个极端是：1 map/1 reduce 的情况，这种情况下实际是非分布式运行。 另一个极端是：1,000,000 个map / 1,000,000 个reduce，这种情况下会由于框架的开销过大而使得系统资源耗尽。
Map的数量通常是由输入文件的DFS blocks 块数量决定的。 那么我们就可以通过调整DFS block 块大小的方式来调整map的数量。一个恰当的map并行度是大约每个节点10-100个map。 Task本身启动要花费一些时间, 所以最好每个map的执行时间至少一分钟。
实际上控制map任务的个数是很 精妙的。mapred.map.tasks参数对于InputFormat设定map执行的个数来说仅仅是一个提示。InputFormat的行为应该把输入数据总的字节值分割成合适数量的片段。但是默认的情况是DFS的块大小会成为对输入数据分割片段大小的上界。一个分割大小的下界可以通过一个mapred.min.split.size参数来设置。因此，如果你有一个大小是10TB的输入数据，并设置DFS块大小为 128M，你必须设置至少82K个map任务，除非你设置的mapred.map.tasks参数比这个数还要大。最终InputFormat 决定了map任务的个数。.
map task的数量可以手动增加，通过 ‘ 的conf.setNumMapTasks(int num)。这个方法能够用来增加map任务的个数，但是不能设定任务的个数小于Hadoop系统通过分割输入数据得到的值。
Reduce数量
Reduce的合适数量应该为0.95 或 1.75 * (nodes * mapred.tasktracker.tasks.maximum)。 对于0.95，当map结束时，所有的reduce立即启动并开始读取map的输出结果。 对于1.75，较快的节点结束第一轮reduce后，可以开始第二轮的reduce任务，从而提高负载均衡。
目前reduce任务的数量 由于输出文件缓冲区大小(io.buffer.size × 2 ×reduce任务个数 && 堆大小)，被限制在大约1000个左右。直到能够指定一个固定的上限后，这个问题最终会被解决。
Reduce任务的数量同时也控制着输出目录下输出文件的数量，但是通常情况下这并不重要，因为下一阶段的 map/reduce任务会把他们分割成更加小的片段。
reduce task的数量也可以像map task一样增加数量，通过 ‘ 的conf.setNumReduceTasks(int num)。
英文原文地址：
本条目发布于。属于分类。作者是。
Spark runs可以运行于Windows 和类 UNIX操作系统中(例如 Linux, Mac OS).
运行前确保系统环境变量中设置 JAVA_HOME 环境变量
进入Spark 根目录，执行如下命令
sbt/sbt assembly
注意： Hadoop 版本
Spark 使用 Hadoop-client 库 同HDFS 和其他 Hadoop支持的存储系统进行交互. 由于不同版本的Hadoop中的HDFS协议都进行了某些修改, 所以当你编译Spark时，确保与集群中相应地hadoop版本一致。默认情况下, Spark 链接Hadoop 1.0.4. 编译时你可以通过设置SPARK_HADOOP_VERSION 修改Spark 默认链接Hadoop版本:
SPARK_HADOOP_VERSION=2.2.0 sbt/sbt assembly
另外, 如果你希望在上运行, 设置 SPARK_YARN 为 true:
SPARK_HADOOP_VERSION=2.0.5-alpha SPARK_YARN=true sbt/sbt assembly
注意：在 Windows操作系统上, 上述设置需要在不同的行进行。例如, set SPARK_HADOOP_VERSION=1.2.1.
本条目发布于。属于分类。作者是。
互联网上首屈一指的HTTP服务器
Abdera项目的目标是建立一个功能完备，高效能的IETF Atom联合格式（RFC4287）和Atom发布协议（RFC5023）规范的实现。
Accumulo 是一个可靠的、可伸缩的、高性能的排序分布式的 Key-Value 存储解决方案，基于单元访问控制以及可定制的服务器端处理。使用
Google BigTable 设计思路，基于 Apache Hadoop、Zookeeper 和 Thrift 构建。
ACE [1]是一个软件发布框架，用于管理和发布模块化软件的组件、配置数据、其他基于OSGi的产品以及相关目标系统。Apache
ACE包含了一组OSGi包，允许开发者轻松管理软件组件安装中依赖关系、部署和反馈。
Apache ACE最初由Luminis开发，在2009年捐赠给了Apache
Incubator（孵化器），随着国际中不同开发者的加入，逐渐形成了一个较成功的社区。
对此，Apache ACE副总裁Marcel Offermans称，“我们很高兴看到ACE已作为顶级项目成功毕业，这种方式（Apache方式）将会带来更广泛的合作，以及利用集体的专业知识，为项目带来多样性的发展。”
Apache软件基金会（ASF）已经宣布Apache ACE已经从项目孵化器中毕业，成为顶级开源项目。
是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS
Provider实现，尽管JMS规范出台已经是很久的事情了，但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。
Airavata[1]是目前用来建立科学网关的软件工具包，但具有更广泛的潜在用途。它提供的功能组成，管理，执行和监测小范围从本地集群，以国家电网和云计算的计算资源进行大规模的应用和工作流程。小工具接口，Airavata后端服务可以部署在开放社会的容器，如Apache
Rave 和修改，以满足他们的需求。 airavata构建面向服务的计算，分布式消息，和工作流程的组成和业务流程的一般概念
Ambari是对Hadoop进行监控、管理和生命周期管理的基于网页的开源项目。它也是一个为Hortonworks数据平台选择管理组建的项目。
Ant,是一个将软件编译、测试、部署等步骤联系在一起加以自动化的一个工具，大多用于Java环境中的软件开发。由Apache软件基金会所提供。
To Triples (any23) is a library, a web service and a command line tool that
extracts structured data in RDF format from a variety of Web documents.
Currently it supports the following input formats:
RDF/XML, Turtle, Notation 3
RDFa with RDFa1.1 prefix mechanism
Microformats: Adr, Geo, hCalendar, hCard, hListing, hResume, hReview,
License, XFN and Species
HTML5 Microdata: (such as Schema.org)
CSV: Comma Separated Values with separator autodetection.
A detailed description of available extractors is here.
APR(Apache
portable Run-time
libraries，Apache可移植运行库)的目的如其名称一样，主要为上层的应用程序提供一个可以跨越多操作系统平台使用的底层支持接口库。
Archiva是一套可扩展的Artifact
Repository管理系统。它能够与Maven，Continuum和ANT等构建工具完美结合。Archiva提供的功能包括：远程Repository代理，基于角色的安全访问管理，Artifact分发、维护、查询，生成使用报告，提供基于Web的管理界面等。
项目提供了一组可嵌入式的 Java 组件，用于企业 OSGi 应用编程模型，该项目还包含了 OSGI 联盟企业专家组的规范实现和扩展。
Avro是一个数据序列化的系统，可以将数据结构或对象转化为便于存储或传输的格式，特别是在设计之初它可以用来支持数据密集型应用，适合于大规模数据的存储和交换。
著名的Apache
Axis，以及第二代Apache Axis2，是两个Web服务容器，可以帮助用户创建，部署和运行Web服务。
Axis2可以使用Java和C语言
Bigtop是去年apache基金会推出的一个对Hadoop及其周边生态进行打包，分发和测试的工具。
Bloodhound
(寻血猎犬) 是Apache的一个项目，提供了一个工具来跟踪项目的进展和缺陷，主要侧重于软件项目。Bloodhound 基于著名的 Trac
项目，提供问题跟踪、储存、方便的浏览和简单的wiki语法参考。Bloodhound 的目的是为多个软件项目管理提供直观的支持、先进友好的 UI
接口和安装简单的一些最重要的 Trac的默认提供的插件。
Buildr是一个简单直观的Java项目构建系统，在进行了10个月的开发并获得许多正面反馈之后，Apache基金会将会向Buildr敞开大门并最终接手这个项目，这将是Apache基金会的第一个Ruby项目
BVal delivers an implementation of the Java Bean Validation (JSR303)
Specification which is TCK compliant, works on Java SE 5 or later, and uses
the Apache Software License v2.0.
Camel是Apache基金会下的一个开源项目,它是一个基于规则路由和中介引擎，提供企业集成模式的Java对象的实现，通过应用程序接口（或称为陈述式的Java领域特定语言（DSL））来配置路由和中介的规则。领域特定语言意味着Apache
Camel支持你在的集成开发工具中使用平常的，类型安全的，可自动补全的Java代码来编写路由规则，而不需要大量的XML配置文件。同时，也支持在Spring中使用XML配置定义路由和中介规则。
Cassandra是一套开源分布式数据库管理系统。它最初由Facebook开发，用于储存特别大的数据。
Cayenne是Apache网站上一个开源的数据持久化框架，它提供了一个可视化的工具。
Chemistry是Content Management Interoperability Services (CMIS)
规范的一个开源实现。该项目当前由以下子项目组成：
OpenCMIS – CMIS Java客户端和服务器端类库
cmislib – CMIS Python客户端类库
phpclient – CMIS PHP客户端类库
DotCMIS – CMIS .NET客户端类库
是一个开源的用于监控大型分布式系统的数据收集系统。这是构建在 hadoop 的 hdfs 和 map/reduce 框架之上的，继承了 hadoop
的可伸缩性和鲁棒性。Chukwa 还包含了一个强大和灵活的工具集，可用于展示、监控和分析已收集的数据。
Clerezza是一个基于OSGi（开放服务网关倡议）的服务平台，它提供了一组组件（bundles）用来构建RESTFul
Semantic Web应用和服务。它提供了一个API来访问RDF Graphs，一个Jax RS实现，TypeHandlers:
Jax-RS资源绑定到RDF类型。
核心特性：
基于OSGi平台
REST风格的Web服务框架
基于W3C标准
Database/Triple Store independent
脚本支持（JSR 223兼容）
Click 是一个先进的Java企业版的Web应用程序框架，提供一个基于浏览器的富客户端编程模型。非常简单和易用，一般的开发人员在一天内就可以上手使用。[
CloudStack是一个开源的具有高可用性及扩展性的云计算平台。支持管理大部分主流的hypervisors，如KVM，XenServer，VMware，Oracle
VM，Xen等。
同时CloudStack是一个开源云计算解决方案。可以加速高伸缩性的公共和私有云（IaaS）的部署、管理、配置。使用CloudStack作为基础，数据中心操作者可以快速方便的通过现存基础架构创建云服务
Commons项目的由三部分组成：
The Commons Proper – 一个可重用的Java组件库。(已经发布过的)
The Commons Sandbox – Java组件开发工作区. (正在开发的项目)
The Commons Dormant – 当前处于非活动状态的组件库.(刚启动或者已经停止维护的项目)
建立和维护可重用的Java组件。使用组件可以提高开发效率和质量。
Continuum是一个企业级持续集成服务器。提供的特性包括：自动构建、发布管理、基于角色的权限管理、源码控制系统、与其它流行构建工具相集成。不管你是否需要集中构建，还是开发人员手动控制发布。Continuum都能够帮助你改进质量和维护一个协调的构建环境。
Cordova是PhoneGap贡献给Apache后的开源项目，是从PhoneGap中抽出的核心代码，是驱动PhoneGap的核心引擎。你可以把他想象成类似于Webkit和Google
Chrome的关系。
是一个开源的面向文档的数据库管理系统，可以通过 RESTful JavaScript Object Notation (JSON) API 访问。术语
“Couch” 是 “Cluster Of Unreliable Commodity Hardware” 的首字母缩写，它反映了 CouchDB
的目标具有高度可伸缩性，提供了高可用性和高可靠性，即使运行在容易出现故障的硬件上也是如此。CouchDB 最初是用 C++ 编写的，但在 2008 年 4
月，这个项目转移到 Erlang OTP 平台进行容错测试。
Crunch（孵化器项目）是基于Google的FlumeJava库编写的Java库，用于创建MapReduce流水线。与其他用来创建MapReduce作业的高层工具（如Apache
Hive、Apache
Pig和Cascading等）类似，Crunch提供了用于实现如连接数据、执行聚合和排序记录等常见任务的模式库。而与其他工具不同的是，Crunch并不强制所有输入遵循同一数据类型。相反，Crunch使用了一种定制的类型系统，非常灵活，能够直接处理复杂数据类型，如时间序列、HDF5文件、Apache
HBase表和序列化对象（像protocol buffer或Avro记录）等。
临床的文本分析和知识提取系统 (cTAKES)
是一个开源的自然语言处理系统，用于从临床电子病历自由文本中抽取信息。可处理临床笔记抽取出统一的医学语言系统(UMLS)——药物,疾病/障碍,标志/症状,解剖网站和程序等。
的客户端调用过于复杂，Apache Curator 就是为了简化zookeeper客户端调用而生，利用它，可以更好的使用zookeeper。
CXF是一个开源的，全功能的，容易使用的Web服务框架。CXF是两个项目的结合：由IONA技术公司（现在是Progress的一部分）开发的Celtix和由Codehaus主持的团队开发的XFire，合并是由人们在在Apache软件基金会共同完成的。CXF的名字来源于”Celtix”和”XFire”的首字母。
DirectMemory 是一个多层的缓存系统，特性包括无堆的内存管理用于支持大规模的 Java 对象，而不会影响 JVM 垃圾收集器的性能。
Directory Studio是一个LDAP工具平台，支持连接到任何 LDAP服务器并进行管理和开发工作，但主要还是设计用于Apache
Directory Server。功能包括：LDAP浏览器、LDIF编辑器、Schema编辑器、嵌入式 ApacheDS、ACI编辑器。
Empire-db是一个开源的关系型数据持久化组件，能够实现数据库无关的动态查询定义，简便的数据读取和更新。与其它持久化组件相比如：Hibernate、TopLink、iBATIS或JPA实现，Empire-db更注重编译期类型安全，减少冗余，开发效率的改进。
Empire-db所有的数据库实体都通过动态bean进行管理，因此允许在运行期改变数据模型。
Felix是一个OSGi版本4规范的Apache实现。OSGi是一个基于Java的服务平台规范，其目标是被需要长时间运行、动态更新、对运行环境破坏最小化的系统所使用。有许多公司（包括Eclipse
IDE，它是第一个采用OSGi技术的重要项目）已经使用OSGi去创建其微内核和插件架构，以允许在运行时刻获得好的模块化和动态组装特性。几个其他项目如Apache
Directory、Geronimo、Jackrabbit、Spring以及JOnAS也都正在转向采用OSGi。
Flex（前称Adobe Flex）是最初由Macromedia公司在2004年3月发布的，基于其专有的Macromedia
Flash平台，它是涵盖了支持RIA（Rich Internet Applications）的开发和部署的一系列技术组合。
Flume是Cloudera提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据；同时，Flume提供对数据进行简单处理，并写到各种数据接受方（可定制）的能力。
Flume最早是Cloudera提供的日志收集系统，目前是Apache下的一个孵化项目，Flume支持在日志系统中定制各类数据发送方，用于收集数据；同时，Flume提供对数据进行简单处理，并写到各种数据接受方（可定制）的能力
Flume提供了从console（控制台）、RPC（Thrift-RPC）、text（文件）、tail（UNIX
tail）、syslog（syslog日志系统，支持TCP和UDP等2种模式），exec（命令执行）等数据源上收集数据的能力。
Forrest是一个把来自各种不同的输入数据源转换成用一种或多种输出格式(比如HTML,PDF等)来统一显示的发布系统。它基于Apache
Cocoon并分离了内容与内容结构,不仅可以生成静态的文档也可以当作一个动态的服务器。
Geronimo 是 Apache 软件基金会的开放源码J2EE服务器，它集成了众多先进技术和设计理念。
这些技术和理念大多源自独立的项目，配置和部署模型也各不相同。 Geronimo能将这些项目和方法的配置及部署完全整合到一个统一、易用的模型中。
Giraph 是一个可伸缩的分布式迭代图处理系统，灵感来自 BSP (bulk synchronous parallel) 和 Google 的
Pregel. Giraph 区别于其他项目的是开源、基于 Hadoop 的架构等。
Gora是一个开源的ORM框架，主要为大数据提供内存数据模型与数据的持久化。目前Gora支持对于列数据、key-value数据，文档数据与RDBMS数据的存储，还支持使用Apache
Hadoop来对对大数据进行分析。
Hadoop是一款支持数据密集型分布式应用并以Apache
2.0许可协议发布的开源软件框架。它支持在商品硬件构建的大型集群上运行的应用程序。Hadoop是根据Google公司发表的MapReduce和Google档案系统的论文自行实作而成。
是个计算框架，基于BSP (Bulk Synchronous Parallel大容量同步并行)计算技术，主要针对大规模科学的计算。
HBase是一个分布式的、面向列的开源数据库，该技术来源于
Fay Chang 所撰写的Google论文“Bigtable：一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统（File
System）所提供的分布式数据存储一样，HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。
hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为MapReduce任务进行运行。
其优点是学习成本低，可以通过类SQL语句快速实现简单的MapReduce统计，不必开发专门的MapReduce应用，十分适合数据仓库的统计分析。
基于对HTTP协议良好的支持和扩展的设计，HttpComponents[1]也许会被正在构建HTTP客户端或者服务器端应用的人所感兴趣：比如WEB浏览器、网页蜘蛛（爬虫）、HTTP代理、WEB服务库、或是基于调整或扩展HTTP协议的分布式通信系统。
Isis是一个用于快速开发领域驱动（domain-driven）应用程序的Java框架。开发者编写实体业务逻辑、域服务、仓储，该框架会动态生成一个域模型表征作为web应用或RESTful
Jackrabbit 是由 Apache Foundation 提供的 JSR-170 的开放源码实现..
James 简称 James, 是 Java Apache Mail Enterprise Server的缩写。James
是100%基于Java的电子邮件服务器。它是一种独立的邮件服务器，并提供了一个完整的电子邮件解决方案，用来收、发电子邮件。
是一个开源的Java类库，用来帮你开始云计算应用开发，并可重用已有的Java和Clojure技能。该API提供云计算环境的可移植抽象层以及云规范特性，支持包括
Amazon, VMWare, Azure, and Rackspace 等云计算平台。
Jena是一个Java工具箱用于开发基于RDF与OWL语义(semantic)Web应用程序。它提供了一个RDF
API；ARP，一个RDF解析器；SPARQL，W3C RDF查询语言；一个OWL API；和基于规则的RDFS与OWL接口。
ApacheJMeter是一个专门为运行和服务器装载测试而设计的、100％的纯Java桌面运行程序。原先它是为Web/HTTP测试而设计的，但是它已经扩展以支持各种各样的测试模块。
jspwiki是一个不错的wiki引擎，纯jsp/servlet写的。JSPWiki不使用现成的数据库管理软件，所有的文件以文本文件的形式存放。它利用类似CVS的机制保证了文件版本的完整性。支持中文，支持版本比较、权限管理等功能！
(音”Judy”)是一个开源的UDDI的Java实现。主要特性包括：
支持从JDK1.3到1.6
遵循UDDI 2.0
支持各种ANSI标准的SQL数据库
Kafka是一个分布式的、分区的、多复本的日志提交服务。它通过一种独一无二的设计提供了一个消息系统的功能。
Karaf是一个基于OSGi的运行环境，它提供了一个轻量级的OSGi容器，可以用于部署各种组件和应用程序。它提供了很多的组件和功能用于帮助开发人员更加灵活的部署应用，如:热部署，动态配置，能够集成到操作系统中作为一个服务，提供可扩展的shell
控制台，可使用任意SSH客户端连到Karaf并在控制台中运行命令，提供基于JAAS的安全框架，提供简单的命令来管理多个实例，可以通过控制台创建、删除、启动、停止Karaf实例等。同时Karaf作为一款成熟而且优秀的OSGi运行环境以及容器已经被诸多Apache项目作为基础容器,例如:Apache
Geronimo，Apache ServiceMix，Fuse ESB，由此可见Karaf在性能，功能和稳定性上都是个不错的选择。
Lenya 是java的开源内容管理系统。它基于一些标准的技术比如XML 与 XSLT。它其中的代码核心来自于另外一个开源项目Cocoon
是一个访问云计算服务的统一接口，该项目已经成为 Apache 组织的顶级项目，采用 Python 开发。
Lucene 是一种适用于多种应用程序(包括您最喜欢的 Web 站点或者公司内部网)的健壮开源搜索解决方案
Lucene.net是Lucene的.net移植版本，是一个开源的全文检索引擎开发包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎。开发人员可以基于Lucene.net实现全文检索的功能。
Lucene.net是Apache软件基金会赞助的开源项目，基于Apache License协议。
Lucy 是一个全文搜索引擎库，使用 C 语言编写，主要面向一些动态语言，目前提供 Perl 语言的绑定。相当于是 C 语言版的 Lucene 。
是 Apache Software Foundation（ASF）
旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序。Apache
Mahout项目已经发展到了它的第三个年头，目前已经有了三个公共发行版本。Mahout包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用
Apache Hadoop 库，Mahout 可以有效地扩展到云中。
ManifoldCF 提供一个开源框架，用于连接源内容库，如：Microsoft Sharepoint、EMC Documentum等, 到目标库或索引,
如Apache Solr、Open Search Server或ElasticSearch等。Apache
ManifoldCF也为目标库定义了一个安全模型允许执行源库的安全策略。
Marmotta 项目的目的是提供 Linked Data Platform 的开源实现，可让组织轻松的使用、扩展和发布 Linked Data
或者构建基于 Linked Data 的应用。
Maven，是一个软件（特别是Java软件）项目管理及自动构建工具，由Apache软件基金会所提供。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。曾是Jakarta项目的子项目，现为独立Apache项目。
Mesos是一个集群管理器，提供了有效的、跨分布式应用或框架的资源隔离和共享，可以运行Hadoop、MPI、Hypertable、Spark。
MINA是一个网络应用程序框架，用来帮助用户简单地开发高性能和高可靠性的网络应用程序。它提供了一个通过Java
NIO在不同的传输例如TCP/IP和UDP/IP上抽象的事件驱动的异步API。
Apache MRUnit 的第一次发布的版本，MRUnit 是帮助开发者做 Apache Hadoop MapReduce 任务单元测试的 Java
myfaces是Apache软件基金的一个项目，它实现了JSF框架。
是一个开源Java 实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。
ODE是一个WS-BPEL兼容的Web服务编配引擎，它可以使开发人员根据以BPEL XML语法写成的过程描述来编配Web服务。
WS-BPEL是一个最初由IBM和Microsoft开发，目前由OASIS Web服务业务流程执行语言（WSBPEL）技术委员会
维护的规范。工作组成员包括IBM、BEA、Adobe、JBoss、SAP、Active.Endpoints、Tibco、WebMethods、Oracle等等。
OFBiz是一个非常著名的电子商务平台，是一个非常著名的开源项目，提供了创建基于最新J2EE/XML规范和技术标准，构建大中型企业级、跨平台、跨数据库、跨应用服务器的多层、分布式电子商务类WEB应用系统的框架。
OFBiz最主要的特点是OFBiz提供了一整套的开发基于Java的web应用程序的组件和工具。包括实体引擎, 服务引擎, 消息引擎, 工作流引擎,
规则引擎等。
OFBiz 已经正式成为 Apache 的顶级项目: Apache OFBiz。
Oltu是OAuth协议的Java语言实现
OODT (Object Oriented Data Technology)
面向对象的数据技术，开发和促进科学数据管理和归档制度，使跨学科和天体物理学之间的互操作性，行星和空间科学数据系统。使用OODT的分布式对象和数据库的框架内，由来自世界各地科学家和工程师在这些不同的学科收集的数据可以联合搜索，存储，检索和分析。Apache
OODT 的目标是开发一个这样的框架，由社区将使用它，并执行有效率的不断输入。
Oozie是一个开源的工作流和协作服务引擎,基于 Apache Hadoop 的数据处理任务。Oozie
是可扩展的、可伸缩的面向数据的服务,运行在Hadoop 平台上。
是 Apache 组织提供的 JPA 标准实现。
OpenMeetings 2.1.0 发布，这是 OpenMeetings 成为 Apache 基金会顶级项目后首次发布的版本。该版本改进了和
Asterisk 的集成、改进音频和视频质量、私人聊天模式、短信发送模块、网络测试工具、提升邮件发送程序、日程管理和聊天室接口、集群功能、HTML5
UI等等，OpenMeetings是一个多语言可定制的视频会议和协作系统。它支持音频、视频，能让你查看每个与会者的桌面。OpenMeetings还包含一个白板，通过白板可以导入各种格式的图片和涂鸦。
是一个机器学习工具包，用于处理自然语言文本。支持大多数常用的 NLP 任务，例如：标识化、句子切分、部分词性标注、名称抽取、组块、解析等。
OpenOffice，又称OpenOffice、AOO，原称为OpenOffice.org，是一套开放源代码的办公室软件，可以在多种操作系统上运作。默认的文件交换格式是已经成为ISO标准的开放文件格式（ODF，OpenDocument
Format），此外也支持Microsoft Office 97至2010[注
1]的文件格式，以及其余常见的文档文件。软件通常称为“OpenOffice”或简称“OOo”，但因为商标的争议，正规的叫法是“OpenOffice.org”[6]。
OpenWebBeans将会成为一款对被定义为JSR-299的Web
Beans说明实现程序，此外它还获得了ASL的许可。
PDFbox是一个开源的、基于Java的、支持PDF文档生成的工具库，它可以用于创建新的PDF文档，修改现有的PDF文档，还可以从PDF文档中提取所需的内容。Apache
PDFBox还包含了数个命令行工具。
最初的设计者为拉里·沃尔（Larry Wall），他于日发表。Perl借取了C、sed、awk、shell
scripting以及很多其他程序语言的特性。其中最重要的特性是它内部集成了正则表达式的功能，以及巨大的第三方代码库CPAN。简而言之，Perl象C一样强大，象awk、sed等脚本描述语言一样方便。Perl
一般被称为“实用报表提取语言”（Practical Extraction and Report
Language），你也可能看到“perl”，所有的字母都是小写的。一般，“Perl”，有大写的 P，是指语言本身，而“perl”，小写的
p，是指程序运行的解释器。
Pig 是一个高级过程语言，适合于使用 Hadoop 和 MapReduce 平台来查询大型半结构化数据集。通过允许对分布式数据集进行类似 SQL
的查询，Pig 可以简化 Hadoop 的使用
Pivot是个开源项目，旨在通过Java创建一个现代化、富客户端的开发平台。Pivot起初是VMWare在2007年的一个研发项目，后来在2008年基于Apache
2.0协议开源了；去年Pivot加入到了Apache
Incubator中并于12月成为Apache顶级项目。目前的Pivot完全是由软件开发社区推进的。
Pivot对自己的定位是现代化的RIA工具集，构建在Java2D之上并使用了MVC模式。可以通过Java、JavaScript以及XML（WTKX）编写Pivot应用。
Pivot带有一个GUI库和一个框架以简化GUI应用的创建
POI 是用Java编写的免费开源的跨平台的 Java API，Apache POI提供API给Java程式对Microsoft
Office格式档案读和写的功能。POI为“Poor Obfuscation Implementation”的首字母缩写，意为“可怜的模糊实现”。
Portals是一个协作的软件开发项目，致力于在广阔的平台和编程语言范围内，提供功能齐全的、商业品质的，及免费的门户网站相关软件。
Apache Portals是Apache基金会系统门户方面的顶级工程，子工程包括：
Apache Jetspeed-2
Apache Portals Pluto
Apache Portals Applications
Apache Portals Bridges
Apache Jetspeed-1
Qpid是最新开放企业信息标准AMQP（Advanced Message Queuing
Protocol）的一个开源实现。Java版实现完全支持JMS标准，可运行在任意Java平台上。此外Qpid还提供AMQP Client
APIs的各种语言实现包括：
Java, fully conformant with JMS 1.1
C# .NET, 0-10 using WCF
Rave 是一个全新的 Web 和社交混搭引擎
River 是一个分布式计算的架构，基于原 Sun 的 JSK Starter Kit 源码，主要使用 Jini 规范。
Roller是Apache的开源的Java版本的WebBlog系统
发展XML安全性方面的项目
ServiceMix是JBI规范的一种实现。它包涵了许多JBI组件，这些组件支持多种协议，比如JMS,HTTP,FTP,FILE等。同时也实现了EIP，规则和调度。
Shindig是一个参考容器，可以运行在任何网站上，用来支持OpenSocial的社交应用
Shiro 是一个框架，可用于身份验证和授权。
SIS 是一个空间的框架，可以更好地搜索，数据聚类，归档，或任何其他相关的空间坐标表示的需要。
Sling是Java平台上的开源Web框架，在JCR内容库上创建面向内容的应用。
SpamAssassin是开源垃圾邮件过滤软件的领导者，广泛在各个国家地区及本地ISP使用，包括邮件服务提供商、财富500强企业、小到企业商业、
教育部门、政府及个体私人等
Sqoop是一个用来将Hadoop和关系型数据库中的数据相互转移的工具，可以将一个关系型数据库（例如
： MySQL ,Oracle ,Postgres等）中的数据导进到Hadoop的HDFS中，也可以将HDFS的数据导进到关系型数据库中。
Stanbol 是一个为语义内容管理设计的模块化的软件堆栈和可重用组件
STeVe is Apache’s Python based single transferable vote software system that
the Foundation uses to handle things like voting in our new Board of
ApacheStruts框架是一个一个基于
Java Servlets,JavaBeans, 和 JavaServer Pages
(JSP)的Web应用框架的开源项目，Struts基于Model-View-Controller (MVC)的设计模式，可以用来构件复杂的Web应用。
Subversion（简称SVN，svn），是一个开放源代码的版本控制系统，相对于的RCS、CVS，采用了分支管理系统，它的设计目标就是取代CVS。互联网上越来越多的控制服务从CVS转移到Subversion。
是一个简单的 XML 和 Web 服务管理与集成代理，可用于构成 SOA 和企业服务总线（ESB）的基础。Synapse是 Web 服务项目中一项成熟的
Apache 活动，并且是非常成功的 Apache Axis2 项目的一个分支。它提供了中介、管理、以及在各种不同的应用程序之间转换 XML
消息的能力
Syncope 是用在企业环境的数字身份管理，在JEE技术的实施和Apache 2.0许可下发布的开源系统。
Tapestry是一个使用Java语言编写的开源框架，用于创建动态的、健壮的、高灵活性的web应用程序。Tapestry框架构筑在标准的Java
Servlet API之上，因此它能够很好地兼容任何servlet容器或者应用服务。
Tcl is an umbrella for Tcl-Apache integration efforts. These projects combine
the power of the Apache web server with the capabilities of the mature,
robust and flexible Tcl scripting language.
thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在
C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript,
Node.js, Smalltalk, and OCaml 这些编程语言间无缝结合的、高效的服务。
Tika 利用现有的解析类库，从不同格式的文档中（例如HTML, PDF, Doc)，侦测和提取出元数据和结构化内容。
功能包括：
侦测文档的类型，字符编码，语言，等其他现有文档的属性。
提取结构化的文字内容。
该项目的目标使用群体主要为搜索引擎以及其他内容索引和分析工具。编程语言为Java.
是一种JSP布局框架，主要目的是为了将复数的jsp页面作为一个的页面的部分机能，然后用来组合成一个最终表示用页面用的，这样的话，便于对页面的各个机能的变更及维护。
Tiles使得struts在页面的处理方面多了一种选择。并且更容易实现代码的重用。
服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP
程序的首选。
TomEE，该产品已通过Java EE 6 Web Profile认证，主要由Apache Tomcat、Apache
OpenWebBeans、Apache MyFaces、Apache ActiveMQ、Apache OpenJPA和Apache
CXF组成。最初被命名为Apache+OpenEJB，后来为了表达包含其他Java EE的组件实现，被重命名为Apache TomEE。
Traffic Server（ATS或TS）是一个高性能的、模块化的HTTP代理和缓存服务器，与 Nginx 和 Squid 类似。
Turbine是基于Servlet的框架包，也是开放源代码Jakarta项目。目前还没有关于Turbine的大量文档。它类似于Struts，但是
有一些主要区别。突出的一点就是它并没有与JSP耦合。Turbine的特点是它提供了大量可重用的组件。
Tuscany 提供全方位的开源SOA基础架构以利于开发, 组装, 发布, 管理构件式应用服务(Composite Applications)及数据处理.
该项目实现服务构件体系(SCA: Service Component Architecture)和服务数据对象(SDO: Service Data
Objects)等OASIS OpenCSA标准.
是UIMA定义的Apache开源实现。UIMA是一个用于分析非结构化内容（比如文本、视频和音频）的组件架构和软件框架实现。这个框架的目的是为非结构化分析提供一个通用的平台，从而提供能够减少重复开发的可重用分析组件。
VCL 是一个自服务的系统，为最终用户提供专用计算环境的远程访问环境。典型的使用场景是数据中心，也可以是物理刀片服务器、传统机架服务器或者虚拟机。VCL
也可以提供独立机器的代理访问。
而 VCL 的目的就是让用户通过 Web 界面来有限时间的使用这些计算资源。通过调度 API 可用于自动化管理服务器集群和 HPC 集群。
Velocity是一个基于java的模板引擎（template
engine）。它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。
Apache Web Services project is the home of a number of Web services related
projects. For more information and downloads, visit the individual project
pages listed below.
Whirr是一套运行于云服务的类库（包括Hadoop），可提供高度的互补性。Whirr现今相对中立，当前支持Amazon EC2和Rackspace服务。
Wicket是一个Java
语言的Web开发框架，与Struts，WebWork，Tapestry
相类似。其特点在于对Html和代码进行了有效的分离（有利于程序员和美工的合作），基于规则的配置(减少了XML
等配置文件的使用)，学习曲线较低（开发方式与C/S相似），更加易于调试（错误类型比较少，而且容易定位）。
Wink就是一个纯Java的REST框架。它完整的实现了JSR
311并扩展了部分功能，此外还提供了良好的扩展性，难能可贵的是还可以与流行的Java框架Spring无缝集成。
Wookie 是一个 Apache Software Foundation 的孵化项目，它能够同时作为 Google Wave Gadgets 和 W3C
Widget 包的服务器。 Apache Wookie 是一个服务器应用，可以作为一个 Web 应用下载安装，或者作为单独的服务器运行
xalan是一套xslt处理器，用来将XML文件转换为HTML,TEXT和XML等其他类型文件格式。支持XSLT1.0和XPATH
1.0版。开发人员可以通过命令行方式或在JAVA APPLET和SERVLET中使用，并可以作为自己开发的应用程序的类库使用。
Xerces是由Apache组织所推动的一项XML文档解析开源项目,它目前有多种语言版本包括JAVA、C++、PERL、COM等。[1]
Xerces是一个开放源代码的XML语法分析器。
XMLBeans是一个XML-Java绑定工具，利用它可以很方便地解析XML文档。
ZooKeeper是Hadoop的正式子项目，它是一个针对大型分布式系统的可靠协调系统，提供的功能包括：配置维护、名字服务、分布式同步、组服务等。ZooKeeper的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功能稳定的系统提供给用户
本条目发布于。属于分类。作者是。
编译thrift0.9.1报错
/bin/bash ../../libtool –tag=CXX
–mode=link g++ -Wall -g -O2 -L/usr/lib
-o libtestgencpp.la
ThriftTest_constants.lo ThriftTest_types.lo ../../lib/cpp/libthrift.la -lssl -lcrypto -lrt -lpthread
libtool: link: ar cru .libs/libtestgencpp.a .libs/ThriftTest_constants.o .libs/ThriftTest_types.o
ar: .libs/ThriftTest_constants.o: No such file or directory
make[3]: *** [libtestgencpp.la] Error 1
make[3]: Leaving directory `/home/bcc/thrift-0.9.1/test/cpp’
make[2]: *** [all-recursive] Error 1
make[2]: Leaving directory `/home/bcc/thrift-0.9.1/test’
make[1]: *** [all-recursive] Error 1
make[1]: Leaving directory `/home/bcc/thrift-0.9.1′
make: *** [all] Error 2
可以有两种方法
方法一：把c++选项关闭，原因貌似和libtool path有关
./configure -with-cpp=no
方法二：注意如果要编译C++库的话，会出现上面的错误，原因是编译文件路径有问题，可以将已经编译的test/cpp/*.o复制到test/cpp/.libs后，继续编译就可以了
本条目发布于。属于分类。作者是。
一、实验环境：
本文的环境搭建是: Mac OS 中利用virtualbox虚拟三台基于centos的服务器。如下图
IP 域名配置表如下：
lhmaster.lihui.hadoop
192.168.1.4
Centos 6.3
lhslave01.lihui.hadoop
192.168.1.5
Centos 6.3
lhslave02.lihui.hadoop
192.168.1.6
Centos 6.3
二. 部署前准备：
集群部署涉及的软件包括： jdk ,ssh ,dns, nfs 和 hadoop-1.2.1
1.配置JAVA, Hadoop环境变量:
第一步：terminal中输入命令 vi /etc/profile
第二步：在编辑状态下加入如下的环境变量
#setJava environment
exportJAVA_HOME=/usr/java/jdk1.7.0_25
exportCLASSPATH=./:$JAVA_HOME/lib:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
exportPATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME
#sethadoop environment
exportHADOOP_HOME=/home/lihui/hadoop/hadoop-1.2.1
exportPATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/conf
三.配置DNS服务器
说明：在生产的hadoop集群环境中，由于服务器可能会有许多台，通过配置DNS映射机器名，相比配置/etc/host方法，可以避免在每个节点都配置各自
的host文件，而且在新增节点时也不需要修改每个节点的/etc/host的主机名-IP映射文件。减少了配置步骤和时间，便于管理。
详细步骤见：
四. 配置NFS服务器进行SSH免密码登录
说明：通过NFS配置ssh免密码连入时，当我们有新的节点接入时，不再需要分别向其它节点各自添加自己公钥信息，只需要把公钥信息追加到共享的
authorized_keys公钥当中，其它节点就直接指向最新的公钥文件。便于分配公钥和管理。
详细步骤见：
五. hadoop 相关配置文件 修改
1：hadoop-env.sh 修改：
修改JAVA_HOME目录
2：core-site.xml 修改
在其中增加两个属性，如下图：
3: hdfs-site.xml 修改
增加属性如下：
4:mapred-site.xml 修改
增加属性如下：
5:masters 修改
6：slaves 修改
六. 向各个结点复制 配置好的hadoop
运行 scp.sh 脚本 即可完成向各个结点的复制
scp.sh 脚本生成步骤：
七. 格式化并运行hadoop
2：启动hadoop
3: 查看运行进程
4：进入web ui 查看运行状态
50030 端口：
50070 端口 查看：
本条目发布于。属于分类。作者是。
一、实验环境：
Mac os 下VirtualBox中三台安装centos 6.3虚拟机
lhmaster.lihui.hadoop
192.168.1.4
Centos 6.3
lhslave01.lihui.hadoop
192.168.1.5
Centos 6.3
lhslave02.lihui.hadoop
192.168.1.6
Centos 6.3
二、修改hadoop 下 /conf/slaves 文件 将客户端添加到文件中，每行一个
三、生成拷贝脚本
执行如下命令生成拷贝脚本：
cat slaves | awk ‘{print “scp -rp /home/lihui/hadoop/hadoop-1.2.1 lihui@+:/home/lihui/hadoop”}’ & scp.sh
至此：批量复制脚本生成成功，等hadoop的其他配置完成，即可执行此脚本 将配置好的hadoop 复制到客户端结点上
本条目发布于。属于分类。作者是。
一、实验环境：
Mac os 下 VirtualBox中三台安装centos 6.3虚拟机
共享目录/挂载点
lhmaster.lihui.hadoop
192.168.1.4
Centos 6.3
共享目录：/home/lihui
lhslave01.lihui.hadoop
192.168.1.5
Centos 6.3
挂载点：/nfs_share
lhslave02.lihui.hadoop
192.168.1.6
Centos 6.3
挂载点：/nfs_share
共享目录：
NFS的目录放在了lhmaster主机上
二、安装配置NFS
1:检测系统是否安装NFS及RPCBIND, 测试操作系统中默认已安装：
2:配置nfs开机启动
3:配置共享目录：
1）编辑 /etc/exports, 添加打算共享的目录：
/home/lihui
是NFS要共享的目录
代表所有ip地址
rw为读写，ro为只读
Sync为立刻写入硬盘，rsync为优先写入缓存
No_root_squas root用户具有根目录的完全管理访问权限（这个如果不配置会造成远程root用户只读）
2）查看结果：
3) 重启服务：
4:输出本地挂载点，即共享目录：
5:在客户端配置共享目录，如下
1）客户端挂载共享目录
[root@lhslave01 lihui]# mkdir /nfs_share
[root@lhslave01 lihui]# mount -t nfs 192.168.1.4:/home/lihui /nfs_share/[root@lhslave01 lihui]# cd /nfs_share
bash: cd: /nfs_share: 权限不够
[root@lhslave01 lihui]#
[root@lhslave01 lihui]# su – lihui
[lihui@lhslave01 ~]$ cd /nfs_share
[lihui@lhslave01 nfs_share]$
2）在主机的共享目录创建测试文件
3）在客户端查看生成的共享文件：
[lihui@lhslave01 nfs_share]$
[lihui@lhslave01 nfs_share]$ cd /nfs_share
[lihui@lhslave01 nfs_share]$ ll
-rwxrwxrwx.
0 12月 21 14:20 nfstest.txt
4）按照 1）的方法在 lhslave02中做同样地操作
6：客户端设置开机启动自动挂载共享目录
修改客户端的 /etc/fstab 文件，在文件末尾添加红框内容
三、基于NFS配置ssh免密码登陆
当使用NFS做ssh免密码连接配置时，我们的主要步骤就是把每个节点生成的RSA密钥对中的公钥整合一个共享目录的authorized_keys文件中，
然后创建连接，把各节点公钥文件指向共享的authorized_keys。这种ssh免密码连接方法优点在于，当我们有新的节点接入时，不再需要分别向其它节
点各自添加自己公钥信息，
只需要把公钥信息追加到共享的authorized_keys公钥当中，其它节点就直接指向最新的公钥文件。
但是在有许多台服务器做初始配置ssh时，仍需要在每个节点进行生成RSA密钥对的操作，即下面的第一、二步。相对之前传统的ssh的配置，只是省去
了向各节点copy公钥的步骤，工作量仍是不小的。
1:在各个结点生成RSA秘钥：如下图操作
在 lhslave01, lhslave02 上分别执行 上图中的 命令
生成SSH 秘钥
2：整合各个结点中的秘钥到共享目录的authorized_keys中
1) 共享目录中生成authorized_keys，并将主结点的秘钥添加到文件中
2) 将客户端的ssh秘钥整合到authorized_keys中
2：在各客户端结点创建共享目录文件authorized_keys的软连接
在lhslave02 中做同样地操作
3：测试SSH免密码连接
此时还需要输入密码：原因是 authorized_keys 的权限问题，修改authorized_keys权限
然后测试结果如下：
本条目发布于。属于分类。作者是。
一、实验环境：
Mac os 下 VirtualBox中三台安装centos 6.3虚拟机
lhmaster.lihui.hadoop
192.168.1.4
Centos 6.3
lhslave01.lihui.hadoop
192.168.1.5
Centos 6.3
lhslave02.lihui.hadoop
192.168.1.6
Centos 6.3
配置说明：DNS服务器配置在lhmaster（master）节点上，对lhmaster、lhslave01、lhslave02节点的主机名进行解析。
二、安装配置DNS
1.安装bind软件包
检测bing是否安装，如图所示
未安装执行yum进行安装，如图
安装结果，如图
安装bing其他相关包，如下：
安装结果：如图
2.修改bind配置文件
执行命令 vim /etc/named.conf 修改配置文件named.conf
修改前，如图
修改配置文件named.rfc1912.zones，
在/etc/named.conf 玩呢间最后是named.rfc1912.zones的路径
include “/etc/named.rfc1912.zones”
执行命令 vim /etc/named.rfc.1912.zones
修改结果如下图：
创建上一步中的 域名配置文件lihui.hadoop.zone和反向配置文件1.168.192.in-addr.zone
如下命令：
[root@lhmaster lihui]# cd /var/named
[root@lhmaster named]# ls
named.empty
named.loopback
named.localhost
[root@lhmaster named]# cp -p named.localhost lihui.hadoop.zone
[root@lhmaster named]# cp -p named.localhost 1.168.192.in-addr.zone
[root@lhmaster named]# ls
1.168.192.in-addr.zone
named.empty
lihui.hadoop.zone
named.localhost
named.loopback
–修改lihui.hadoop.zone和1.168.192.in-addr.zone
lihui.hadoop.zone中添加正向配置，如下：
1.168.192.in-addr.zone中添加反向配置，如下：
修改各节点/etc/resolv.conf文件
在每个节点的 /etc/resolv.conf 文件中加入 服务器ip地址
本次测试加入：nameserver 192.168.1.4
注意：目前网上大部分资料中都是如此设置，设置完后运行没有什么问题，但是一旦重启机器后，/etc/resolv.conf 会恢复原值，
所以使用另一种方式就是修改
/etc/sysconfig/network-scripts/ifcfg-eth0
这个文件：在其中加入 DNS1=192.168.4
这样设置后，/etc/resolv.conf里面根本就不需要设置。service network restart　后，可以发现/etc/resolv.conf里面就有刚才加入的dns的解析ip了。
不过对于其他的系统是否也是这样的，要是遇到同样的问题。就这样设一下试试
3.验证测试
本条目发布于。属于分类。作者是。
Apache Spark(TM)是一个轻量，快速，通用的基于内存计算的大规模数据并行计算框架，由UCBerkeley的AMP实验室开发，目前是AFS的顶级项目。
Spark 内存计算比Hadoop MapReduce 快100倍,
相比与磁盘计算快10倍.
Spark 有一个高级的DAG 执行引擎，它能够支持循环数据流和内存计算。
下图为：逻辑回归算法在spark和hadoop中执行时间对比。
逻辑回归：hadoop 和Spark
可以使用Java, Scala 或 Python 快速开发应用程序.
Spark 提供了80多种高级功能，易于构建并行应用程序. 同时还可以通过Scala 和 Python shells 进行交互.
以下为：Word count 在 Spark 执行代码
file = spark.textFile(“hdfs://…”)
file.flatMap(line =& line.split(” “))
.map(word =& (word, 1))
.reduceByKey(_ + _)
可以结合SQL, 数据流和复杂分析.
Spark 支持一系列高级工具： 支持的SQL,
支持机器学习的 ,
和 . 你可以在同一个应用程序中无缝地结合这些框架。.
同Hadoop的集成
Spark 能够运行在Hadoop 2′s YARN 集群上, 同时能够读取存在的Hadoop数据.
如果你已经安装了Hadoop 2 集群, 那么你不需额外安装即可运行Spark. 另外, Spark 可以很容易在 （单机），
上运行.它还能读取
和 任何 Hadoop 数据源的数据.
Spark 被许多组织广泛使用用于处理大规模数据集. 你可以在
或者 页面找到使用示例程序.
通过如下方式与社区进行交流:
进行问题跟踪.
Apache Spark 是由来自超过25家公司的开发者来开发维护. 自2010年项目启动, 已经有超过120名开发者对Spark做出贡献!
项目 (委员) 来自12个组织.
如果你想参与到Spark开发维护中, 或者前边提到的相关框架中, 那么学习一下
(如何贡献).
本条目发布于。属于分类。作者是。
2014年五月 &(1)
2014年四月 &(1)
2014年三月 &(8)}