一台服务器搭建多个spark

1. 一台服务器，部署多个项目

首先确定你需要在什么模式下进行设置，一种是改变端口方法可以同时多个项目进行部署，一种是建立多个虚拟机，进行设置。

2. 一台服务器一般最多搭建几个网站

多少个网站这个没研究过。好像可以开很多 。主要看看你的数据库能最大开多少吧。还有取决于你的F配置。一台服务器是公用一个IP。不是独立的IP。通过这个IP，通过不同的账号上传到不同的文件夹。浏览不同的网站页面。

3. 如何一个ip服务器搭建多个网站

假定我如今用一台win2000服务器供给虚拟主机服务,地址是192.168.1.10.在这台服务器现已安装了Internet服务即IIS6 如今公司请求网络办理员在服务器上运用一个IP为ABCD四个公司树立独立的网站,每个网站具有主机独立的域名.四家网站域名别离为:
经过运用主机头，站点只需一个IP地址即可保护多个站点。客户能够运用不一样的域名访问各自的站点,底子感受不到这些站点在同一主机上.
具体操作如下:
1.在win2003服务器为四家公司树立文件夹,做为WEB站点主目录.如下:
WEB站点主目录 WEB站点
d:weba A公司网站
d:webb B公司网站 bbs.b.com
d:webc C公司网站
d:webd D公司网站
2.运用WEB站点办理导游,别离四家公司树立独立的WEB站点,四者最大的不一样是运用了不一样的主机头名:
A公司站点 B公司站点 C公司站点 D公司站点
IP地址 192.168.1.10
TCP端口 80
权限 读取和运转脚本
主机头名
站点主目录 d:weba d:webb d:webc d:webd
在DNS中将这四个域名注册上,均指向同一地址:192.168.1.10.这么,客户端就能够经过:

3.每个站点的主机头名能够在WEB站点树立导游中设置,它与站点的IP地址,TCP端口在同一屏上.也也许经过该站点->"特点"->"WEB站点"

4. 在linux上如何配置spark环境，在linux上安装scala和spark老是失败

方法/步骤

首先你的机器安装了jdk，我的新机器，所以早上刚在centos上折腾了jdk，没有的也可以去参考下
下载安装包
scala-2.11.4.tgz
spark-1.2.0-bin-hadoop2.4.tgz
后面的包忘了之前哪找的了，需要的可以私我。将包传到服务器，解压
tar zxvf scala-2.11.4.tgz
tar zxvf spark-1.2.0-bin-hadoop2.4.tgz

配置环境变量
vim /etc/profile
加上以下对应内容：
export JAVA_HOME=/home/yy/jdk1.8
export SCALA_HOME=/home/yy/scala
export SPARK_HOME=/home/yy/spark-1.2.0-bin-hadoop2.4
export PATH=$PATH:$JAVA_HOME/bin:$SCALA_HOME/bin:$SPARK_HOME/bin:$SPARK_HOME/sbin
执行source /etc/profile使配置生效

修改spark配置
进入spark-1.2.0-bin-hadoop2.4/conf
复制模板文件：
cp spark-env.sh.template spark-env.sh
cp slaves.template slaves

编辑spark-env.sh
添加上你的对应信息：
export JAVA_HOME=/home/yy/jdk1.8
export SCALA_HOME=/home/yy/scala
export SPARK_MASTER_IP=172.20.0.204
export SPARK_WORKER_MEMORY=2g
export HADOOP_CONF_DIR=/home/yy/spark-1.2.0-bin-hadoop2.4/conf

编辑slaves
添加上你的对应信息，所有的集群的机器：
172.20.0.204
172.20.0.205

到此为止，前面所有的安装配置动作，在你的另一个机器上(所有的slave机器)同样的做一遍，即我这里的205机器

进入spark-1.2.0-bin-hadoop2.4/sbin/目录
执行：./start-all.sh
如果没有设置ssh免密码登陆，会要求输入密码
这时候jps查看多了个master和worker

浏览器查看集群信息
master地址+8080端口

启动Running Applications
在bin目录下执行：
MASTER=spark://172.20.0.204:7077 ./spark-shell
这时候就可以看到运行的app啦

同时可以查看jobs内容

slave机器上也运行app，这时候就可以看到运行的applications有两个啦。

好了，环境就算先搭起来啦，后面就是去调用吧。

http://jingyan..com/article/7e440953308f122fc0e2ef81.html

5. 一台服务器上能同时运行两个数据库服务器吗

1.
一台服务器多个数据库运行，是完全可以的。
2.
服务器安装数据库，不仅可以一个数据库服务，运行多个网站的库。
3.
还可以在同一台服务器，运行多个不同的数据服务。
4.
比如一个mysql，运行多个php站点，多个数据库。
5.
而且还可以一台服务器同时运行，mysql数据库和sqlserver数据库。

6. 如何构建第一个Spark项目代码

操作系统
Window7/Mac
IDE
IntelliJ IDEA Community Edition 14.1.6
下载地址
JDK 1.8.0_65
下载地址
Scala 2.11.7
下载地址
其它环境
Spark:1.4.1
下载地址
Hadoop Yarn:Hadoop 2.5.0-cdh5.3.2
IDE项目创建
新建一个项目
New Project

使用Maven模型创建一个Scala项目

填写自己的GroupId、ArtifactId,Version不需要修改，Maven会根据GroupId生成相应的目录结构，GroupId的取值一般为a.b.c 结构,ArtifactId为项目名称。之后点击next，填写完项目名称和目录，点击finish就可以让maven帮你创建Scala项目

项目创建完成后，目录结构如下

4.为项目添加JDK以及Scala SDK
点击File->Project Structure，在SDKS和Global Libraries中为项目配置环境。

至此整个项目结构、项目环境都搭建好了
编写主函数
主函数的编写在 projectName/src/main/scala/…/下完成，如果按照上述步骤完成代码搭建，将在目录最后发现
MyRouteBuild
MyRouteMain

这两个文件为模块文件，删除MyRouteBuild,重命名MyRouteMain为DirectKafkaWordCount。这里，我使用Spark Streaming官方提供的一个代码为实例代码，代码如下
package org.apache.spark.examples.streaming

import kafka.serializer.StringDecoder

import org.apache.spark.streaming._
import org.apache.spark.streaming.kafka._
import org.apache.spark.SparkConf

object DirectKafkaWordCount {
def main(args: Array[String]) {
if (args.length < 2) {
System.err.println("...")
System.exit(1)
}
//StreamingExamples.setStreamingLogLevels()

val Array(brokers, topics) = args

val sparkConf = new SparkConf().setAppName("DirectKafkaWordCount")
val ssc = new StreamingContext(sparkConf, Seconds(2))

// Create direct kafka stream with brokers and topics
val topicsSet = topics.split(",").toSet
val kafkaParams = Map[String, String]("metadata.broker.list" -> brokers)
val messages = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
ssc, kafkaParams, topicsSet)

// Get the lines, split them into words, count the words and print
val lines = messages.map(_._2)
val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x, 1L)).receByKey(_ + _)
wordCounts.print()

// Start the computation
ssc.start()
ssc.awaitTermination()
}
}

将代码最上面的package org.apache.spark.examples.streaming,替换为DirectKafkaWordCount里的package部分即可。并覆盖DirectKafkaWordCount文件。
至此Spark处理代码已经编写完成。
修改pom.xml,为项目打包做准备
pom.xml中编写了整个项目的依赖关系，这个项目中我们需要导入一些Spark Streaming相关的包。
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.10</artifactId>
<version>1.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming-kafka_2.10</artifactId>
<version>1.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming_2.10</artifactId>
<version>1.4.1</version>
</dependency>

<!-- scala -->
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>2.10.4</version>
</dependency>

除此之外，如果需要把相关依赖打包到最终JAR包中，需要在pom.xml的bulid标签中写入以下配置:
<plugins>
<!-- Plugin to create a single jar that includes all dependencies -->
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.4</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>

<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<executions>
<execution>
<id>scala-compile-first</id>
<phase>process-resources</phase>
<goals>
<goal>add-source</goal>
<goal>compile</goal>
</goals>
</execution>
<execution>
<id>scala-test-compile</id>
<phase>process-test-resources</phase>
<goals>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>

pom.xml文件修改完成后，即可开始maven打包,操作如图:

点击右侧弹出窗口的Execute Maven Goal,在command line中输入clean package

Spark作业提交
在项目projectname/target目录下即可找到两个jar包，其中一个仅包含Scala代码，另一个包含所有依赖的包。
将jar包导到Spark服务器，运行Spark作业，运行操作如下
../bin/spark-submit –master yarn-client –jars ../lib/kafka_2.10-0.8.2.1.jar –class huochen.spark.example.DirectKafkaWordCount sparkExample-1.0-SNAPSHOT-jar-with-dependencies.jar kafka-broker topic
利用spark-submit把任务提交到Yarn集群，即可看到运行结果。

7. 如何在高效的在一台服务器部署多个站点

在同一台服务器里如何运行多个网站，提供WEB、FTP、Mail等服务。
工具/原料
虚拟主机
Apache Web服务软件
方法/步骤
实现方法有三种： 1：IP的方法
①基于IP的方法： 在服务器里绑定多个IP，然后配置WEB服务器，把多个网站绑定在不同的IP上。访问不同的IP，就看到不同的网站。
2：基于主机名的方法
②基于端口的方法： 一个IP地址，通过不同的端口实在不同网站的访问。
3：基于端口方法。
③基于主机名的方法： 设置多个域名的A记录，使它们解析到同一个IP地址上，即同一个服务器上。然后，在服务器上配置WEB服务端，添加多个网站，为每个网站设定一个主机名。因为HTTP协议访问请求里包含有主机名信息，当WEB服务器收到访问请求时，就可以根据不同的主机名来访问不同的网站。

三种虚拟主机实现的基本配置
①基于IP虚拟主机的实现： 多个ip，需要把中心主机取消 打开web服务的主配置文档：vim /etc/httpd/conf/httpd.conf DocumentRoot 注释掉 配置虚拟主机： DocumentRoot "/var/a/html" ServerName DocumentRoot "/var/ab/html" ServerName

vim /etc/hosts 192.168.1.100 192.168.1.101 浏览器中输入IP地址进行实验效果的验证。
②基于端口： DocumentRoot "/var/a/html" ServerName
DocumentRoot "/var/ab/html" ServerName
③基于主机名： 开启：NameVirtualHost 192.168.1.100:80 ServerAdmin DocumentRoot /var/a/html
ServerAdmin DocumentRoot /var/ab/html

8. spark处理数据如何用服务器内存

RDD通过persist方法或cache方法可以将前面的计算结果缓存，但是并不是这两个方法被调用时立即缓存，而是触发后面的action时，该RDD将会被缓存在计算节点的内存中，并供后面重用。通过查看源码发现cache最终也是调用了persist方法，默认的存储级别都是仅在内存存储一份，Spark的存储级别还有好多种，存储级别在object StorageLevel中定义的。缓存有可能丢失，或者存储存储于内存的数据由于内存不足而被删除，RDD的缓存容错机制保证了即使缓存丢失也能保证计算的正确执行。通过基于RDD的一系列转换，丢失的数据会被重算，由于RDD的各个Partition是相对独立的，因此只需要计算丢失的部分即可，并不需要重算全部Partition。
拓展资料：Spark是一种安全的、经正式定义的编程语言，被设计用来支持一些安全或商业集成为关键因素的应用软件的设计。其通过运行用户定义的main函数，在集群上执行各种并发操作和计算Spark提供的最主要的抽象，Spark的正式和明确的定义使得多种静态分析技术在Spark源代码的应用中成为可能。

9. 一台服务器如何建两个或多个网站

给两个网站设不同的主机头。当然。主机头就是你的两个不同的域名。如果怕他们冲突的话，将其中的一个网站的端口号改个不同的。网站默认的端口是80。随便改个不同的就可以。