第4次实践作业

（1）使用Docker-compose实现Tomcat + Nginx负载均衡

1.nginx反向代理原理

反向代理（Reverse Proxy）方式是指以代理服务器来接受Internet上的连接请求，然后将请求转发给内部网络上的服务器；并将从服务器上得到的结果返回给Internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。
反向代理服务器作为内容服务器的负载均衡器时，可以在一个组织内使用多个代理服务器来平衡各 Web 服务器间的网络负载

2.nginx代理tomcat集群

项目结构

nginx配置文件

upstream tomcat_client{
	server t01:8080;
	server t02:8080;
	server t03:8080;
} 
server {
	server_name localhost;
	listen 2504;
	location / {
		proxy_pass http://tomcat_client;
	}
}

docker-compose.yml

version: "3"
services:
  tomcat001:
    image: tomcat:8.5.0
    ports:
      - "8081:8080"
    restart: "always"
    container_name: tomcat001
    volumes:
      - ./tomcat1:/usr/local/tomcat/webapps/ROOT # 挂载web目录
  tomcat002:
    image: tomcat:8.5.0
    ports:
      - "8082:8080"
    container_name: tomcat002
    restart: "always"
    volumes:
      - ./tomcat2:/usr/local/tomcat/webapps/ROOT
  tomcat003:
    image: tomcat:8.5.0
    ports:
      - "8083:8080"
    container_name: tomcat003
    restart: "always"
    volumes:
      - ./tomcat3:/usr/local/tomcat/webapps/ROOT
  nginx:
    image: nginx
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf
    ports:
      - "80:2504"
    container_name: ngx_lr
    links:
      - tomcat001:t01
      - tomcat002:t02
      - tomcat003:t03

3.检查负载均衡

(1)轮询

最基本的配置方法，上面的例子就是轮询的方式，它是upstream模块默认的负载均衡默认策略。每个请求会按时间顺序逐一分配到不同的后端服务器。

(2)weight

权重方式，在轮询策略的基础上指定轮询的几率。weight参数用于指定轮询几率，weight的默认值为1,；weight的数值与访问比率成正比，比如Tomcat 7.0被访问的几率为其他服务器的两倍。
修改配置文件

upstream tomcats_client {
    server t01:8080 weight=1;
    server t02:8080 weight=2;
    server t03:8080 weight=3;
}

可以看出tomcat03被访问到的次数最多，接着是tomcat02，tomcat01

(3)least_conn

把请求转发给连接数较少的后端服务器。轮询算法是把请求平均的转发给各个后端，使它们的负载大致相同；但是，有些请求占用的时间很长，会导致其所在的后端负载较高。这种情况下，least_conn这种方式就可以达到更好的负载均衡效果。
修改配置文件

upstream tomcats_client {
    server t01:8080 weight=2;
    server t02:8080 backup;
    server t03:8080 max_fails=3 fail_timeout=10s;
}

(2) 使用Docker-compose部署javaweb运行环境

对javaweb代码不熟悉，所以采用了老师提供的项目

项目结构

docker-compose.yml

version: '2'
services:
  t01:
    image: tomcat
    hostname: hostname
    container_name: tomcat01
    ports:
      - "5050:8080"
    volumes:
     - ./webapps:/usr/local/tomcat/webapps
     - ./wait-for-it.sh:/wait-for-it.sh
    networks:
      webnet:
        ipv4_address: 15.22.0.15
  t02:
    image: tomcat
    hostname: hostname
    container_name: tomcat02
    ports:
      - "5051:8080"
    volumes:
     - ./webapps:/usr/local/tomcat/webapps
     - ./wait-for-it.sh:/wait-for-it.sh
    networks:
      webnet:
        ipv4_address: 15.22.0.16
  t03:
    image: tomcat
    hostname: hostname
    container_name: tomcat03
    ports:
      - "5052:8080"
    volumes:
     - ./webapps:/usr/local/tomcat/webapps
     - ./wait-for-it.sh:/wait-for-it.sh
    networks:
      webnet:
        ipv4_address: 15.22.0.17  
  mymysql:
    build: .
    image: mysql
    container_name: mymysql
    ports:
      - "3309:3306"
    command: [
            '--character-set-server=utf8mb4',
            '--collation-server=utf8mb4_unicode_ci'
    ]
    environment:
      MYSQL_ROOT_PASSWORD: "123456"
    networks:
      webnet:
        ipv4_address: 15.22.0.6
  nginx:
    image: nginx
    container_name: mynginx
    ports:
      - 8080:8080
    volumes:
      - ./default.conf:/etc/nginx/conf.d/default.conf # 挂载配置文件
    depends_on:
      - t01
      - t02
      - t03
    tty: true
    stdin_open: true
    networks:
      webnet:
        ipv4_address: 15.22.0.7
networks:
 webnet:
   driver: bridge
   ipam:
     config:
       - subnet: 15.22.0.0/24

default.conf

upstream tomcatcl {
	server t01:8080;
	server t02:8080;
	server t03:8080;
} 
 
server {
	listen 8080;
	server_name localhost;
 
        location / {
            proxy_pass http://tomcatcl;
        }
}

通过访问tomcat暴露的端口访问服务

一开始把暴露端口的方式当成反向代理，后来看大佬的博客才发现理解错了，顺便弄清楚了反向代理的原理

通过nginx反向代理访问服务

数据库操作

修改客房表，将房间状态改为预定

新增一条记录，增加商品

（3）使用Docker搭建大数据集群环境

使用Docker搭建Hadoop集群，将Hadoop集群运行在Docker容器中，使Hadoop开发者能够快速便捷地在本机搭建多节点的Hadoop集群

1.在Docker安装Ubuntu系统

从Docker hub上拉取Ubuntu镜像到本地,然后在个人文件下创建一个目录，用于向Docker内部的Ubuntu系统传输文件，在Docker上运行Ubuntu系统

docker pull ubuntu
cd ~
mkdir build
sudo docker run -it -v /home/monster/build:/root/build --name ubuntu ubuntu

2.Ubuntu系统初始化

建议一开始先换源,将/etc/apt/sources.list文件替换为下面内容

# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted universe multiverse

# 预发布软件源，不建议启用
# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-proposed main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-proposed main restricted universe multiverse

1.安装一些软件

apt-get update
apt-get install vim       # 安装vim
apt-get install ssh       # 安装sshd
/etc/init.d/ssh start     # 运行脚本即可开启sshd服务器
vim ~/.bashrc             
/etc/init.d/ssh start  # 在该文件中最后一行添加如下内容

ssh-keygen -t rsa # 配置ssh无密码连接本地sshd服务，一直按回车键即可
cat id_dsa.pub >> authorized_keys

2.安装JDK

apt-get install openjdk-8-jdk #安装JDK
vim ~/.bashrc       # 配置Java环境变量,在最后输入如下内容
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/
export PATH=$PATH:$JAVA_HOME/bin
source ~/.bashrc   # 使.bashrc生效

3.保存镜像文件

我们在Docker内部的容器做的修改是不会自动保存到镜像的，也就是说，我们把容器关闭，然后重新开启容器，则之前的设置会全部消失，因此我们需要保存当前的配置；为了达到复用配置信息，我们在每个步骤完成之后，都保存成一个新的镜像，然后开启保存的新镜像即可；

• 注意：容器不能使用exit来退出，否则就会停掉，可以使用ctrl+p+q（我就是做到保存镜像的时候退出了，然后又重新了一次）

docker login
docker commit <容器id> ubuntu/jdkinstalled 
docker images # 查看是否保存成功

4.安装hadoop

开启保存的那份镜像ubuntu/jdkinstalled

docker run -it -v /home/hadoop/build:/root/build --name ubuntu-jdkinstalled ubuntu/jdkinstalled

开启系统之后，我们把下载下来的Hadoop安装文件放到共享目录/home/hadoop/build下面，然后在Docker内部Ubuntu系统的/root/build目录即可获取到Hadoop安装文件；在Docker内部的Ubuntu系统安装Hadoop和本地安装一样

cd /root/build
tar -zxvf hadoop-3.1.3.tar.gz -C /usr/local 
cd /usr/local/hadoop-3.1.3
./bin/hadoop version

5.配置Hadoop集群

打开hadoop_env.sh文件，修改JAVA_HOME

#假设现在/usr/local/hadoop目录下
vim etc/hadoop/hadoop-env.sh
# 将export JAVA_HOME=${JAVA_HOME}替换成
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/

打开core-site.xml输入以下内容

<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl" ?>
<configuration>
          <property> 
                  <name>hadoop.tmp.dir</name>
                  <value>file:/usr/local/hadoop-3.1.3/tmp</value>
                  <description>Abase for other temporary directories.</description>
          </property>
          <property>
                  <name>fs.defaultFS</name>
                  <value>hdfs://master:9000</value>
          </property>
</configuration>

打开hdfs-site.xml输入以下内容

<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl" ?>
<configuration>
        <property>
                <name>dfs.replication</name>
                <value>1</value>
        </property>
        <property>
                <name>dfs.namenode.name.dir</name>
		        <value>file:/usr/local/hadoop-3.1.3/tmp/dfs/name</value>
	</property>
	<property>
                <name>dfs.datanode.data.dir</name>
                <value>file:/usr/local/hadoop-3.1.3/tmp/dfs/data</value>
	</property>
	<property>
                <name>dfs.permissions.enabled</name>
                <value>false</value>
        </property>
</configuration>

mapred-site.xml

<?xml version="1.0" ?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl" ?>
<configuration>
    <property>
        <name>mapreduce.framework.name</name>
        <value>yarn</value>
    </property>
    <property>
        <name>yarn.app.mapreduce.am.env</name>
        <value>HADOOP_MAPRED_HOME=/usr/local/hadoop-3.1.3</value>
    </property>
    <property>
        <name>mapreduce.map.env</name>
        <value>HADOOP_MAPRED_HOME=/usr/local/hadoop-3.1.3</value>
    </property>
    <property>
        <name>mapreduce.reduce.env</name>
        <value>HADOOP_MAPRED_HOME=/usr/local/hadoop-3.1.3</value>
    </property>
</configuration>

yarn-site.xml

<?xml version="1.0" ?>
<configuration>
<!-- Site specific YARN configuration properties -->
        <property>
               <name>yarn.nodemanager.aux-services</name>
               <value>mapreduce_shuffle</value>
        </property>
        <property>
               <name>yarn.resourcemanager.hostname</name>
               <value>Master</value>
        </property>
        <!--虚拟内存和物理内存比，不加这个模块程序可能跑不起来-->
        <property>
               <name>yarn.nodemanager.vmem-pmem-ratio</name>
               <value>2.5</value>
        </property>
</configuration>

修改脚本文件，进入 /usr/local/hadoop-3.1.3/sbin 在start-dfs.sh和stop-dfs.sh文件末尾添加下面内容

HDFS_DATANODE_USER=root
HADOOP_SECURE_DN_USER=hdfs
HDFS_NAMENODE_USER=root
HDFS_SECONDARYNAMENODE_USER=root

在start-yarn.sh和stop-yarn.sh文件末尾添加下面内容

YARN_RESOURCEMANAGER_USER=root
HADOOP_SECURE_DN_USER=yarn
YARN_NODEMANAGER_USER=root

保存这个镜像，在其他终端输入如下命令
docker commit <容器id> ubuntu/hadoopinstalled
我们在三个终端上开启三个容器运行ubuntu/hadoopinstalled镜像，分别表示Hadoop集群中的master,slave01和slave02

# 第一个终端
docker run -it -h master --name master ubuntu/hadoopinstalled
# 第二个终端
docker run -it -h slave01 --name slave01 ubuntu/hadoopinstalled
# 第三个终端
docker run -it -h slave02 --name slave02 ubuntu/hadoopinstalled

接着配置master,slave01和slave02的地址信息，这样他们才能找到彼此，分别打开/etc/hosts可以查看本机的ip和主机名信息,最后得到三个ip和主机地址信息如下:

172.17.0.5      master
172.17.0.6      slave01
172.17.0.7      slave02

最后把上述三个地址信息分别复制到master,slave01和slave02的/etc/hosts即可，我们可以用如下命令来检测下是否master是否可以连上slave01和slave02

ssh slave01
ssh slave02

打开master上的workers文件，输入两个slave的主机名:

vim /usr/local/hadoop-3.1.3/etc/hadoop/workers
# 将localhost替换成两个slave的主机名
slave01
slave02

Hadoop集群已经配置完成，我们来启动集群
在master终端上，首先进入/usr/local/hadoop-3.1.3，然后运行如下命令:

cd /usr/local/hadoop-3.1.3
bin/hdfs namenode -format #格式化，只有首次启动时需要
sbin/start-all.sh

在master,slave01和slave02上分别运行命令jps查看运行结果

6.运行Hadoop实例程序

因为要用到hdfs，所以我们先在hdfs上创建一个目录:

bin/hdfs dfs -mkdir -p /user/root      #注意input文件夹是在root目录下
bin/hdfs dfs -mkdir input

将/usr/local/hadoop-3.1.3/etc/hadoop/目录下的所有文件拷贝到hdfs上的目录:

hdfs dfs -put ./etc/hadoop/*.xml /user/root/input

然后通过ls命令查看下是否正确将文件上传到hdfs下:

运行下面命令执行实例程序:

hadoop jar /usr/local/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar grep input output 'dfs[a-z.]+'    #运行示例程序grep
hdfs dfs -cat output/*   #查看运行结果

hadoop jar /usr/local/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount input output   #运行示例程序wordcount
hdfs dfs -cat output/*   #查看运行结果

(4)总结

实验花费时间：实验一3小时+实验二6小时+实验三5小时+写博客2小时，实验三因为在大数据实践课上做过所以避免了很多坑，实验二主要是要理解配置文件特别是端口的对应
遇到的问题：

1.保存镜像文件的时候容器停止

这里是因为我在容器内用exit退出，导致容器停止，可以采用ctrl+q+p切出容器，或者打开另外一个终端来保存镜像文件，然后在配置的过程中要及时保存成镜像文件，避免出现错误时返工，配置文件真的耗费太多时间

2.hadoop运行程序之后没有结果

查看log文件，发现input路径里没有文件

解决：创建文件夹的时候input文件夹要放在/user/root/路径下

3.再次启动执行start-all.sh时namenode无法启动

问题出在tmp文件，默认的tmp文件每次重新开机会被清空，与此同时namenode的格式化信息就会丢失，于是我们得重新配置一个tmp文件目录
首先在home目录下建立一个hadoop_tmp目录

sudo mkdir ~/hadoop_tmp (hadoop用户下）

然后修改hadoop/conf目录里面的core-site.xml文件，加入以下节点：

<property>

<name>hadoop.tmp.dir</name>

<value>/usr/local/hadoop_tmp<alue>

<description>A base for other temporary directories.</description>

</property>

或者可以直接之前保存的镜像文件运行一个新的容器，重新格式化一下就可以

4.slave节点上的datanode无法启动

这个在做大数据实践的时候也遇到很多次，主要是每次格式化后，名称结点 的clusterID（集群ID）会被新建，而数据结点的clusterID还是原来的，造成名称结点和数据节点的clusterID不一致。
一种方法时在重新格式化之前先删除hadoop日志文件和缓存文件，然后重新格式化，再启动hadoop进程。
另一种方法是 cd /tmp/dfs/data/current 找到version文件 ，在cd /tmp/dfs/name/current 找到version文件
将name中的 version文件中的ClusterId复制到data/current下的version中，使ClusterId一致
重新启动，jps会发现都在运行了。