2020系统综合实践 第4次实践作业

一、使用Docker-compose实现Tomcat+Nginx负载均衡

1、nginx反向代理原理

多个客户端给服务器发送的请求，nginx服务器接收到之后，按照一定的规则分发给了后端的业务处理服务器进行处理了。此时~请求的来源也就是客户端是明确的，但是请求具体由哪台服务器处理的并不明确了，nginx扮演的就是一个反向代理角色。 反向代理，主要用于服务器集群分布式部署的情况下，反向代理隐藏了服务器的信息。（参考资料：Nginx详解)

2、nginx代理tomcat集群，代理2个以上tomcat

在目录下创建如下文件

docker-compose.yml

version: "3"
services:
    nginx:
        image: nginx
        container_name: yxynginx
        ports:
            - "80:80"
        volumes:
            - ./nginx/default.conf:/etc/nginx/conf.d/default.conf # 挂载配置文件
        depends_on:
            - tomcat01
            - tomcat02
            - tomcat03

    tomcat01:
        image: tomcat
        container_name: yxytomcat1
        volumes:
            - ./tomcat1:/usr/local/tomcat/webapps/ROOT # 挂载web目录

    tomcat02:
        image: tomcat
        container_name: yxytomcat2
        volumes:
            - ./tomcat2:/usr/local/tomcat/webapps/ROOT

    tomcat03:
        image: tomcat
        container_name: yxytomcat3
        volumes:
            - ./tomcat3:/usr/local/tomcat/webapps/ROOT

default.conf

upstream tomcats {
    server yxytomcat1:8080; # 主机名:端口号
    server yxytomcat2:8080; # tomcat默认端口号8080
    server yxytomcat3:8080; # 默认使用轮询策略
}

server {
    listen 80;
    server_name localhost;

    location / {
        proxy_pass http://tomcats; # 请求转向tomcats
    }
}

在tomcat文件夹中打开终端，运行docker-compose

sudo docker-compose up -d

查看容器

3、了解nginx的负载均衡策略，并至少实现nginx的2种负载均衡策略

3.1 轮询策略

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

• nginx配置文件default.conf :

  upstream tomcats {
      server yxytomcat1:8080;
      server yxytomcat2:8080;
      server yxytomcat3:8080;
  }
  ...
  

• 使用简单的爬虫查看(也可以直接在浏览器中访问127.0.0.1)

  #ex4.py
  import requests
  
  url="http://127.0.0.1"
  
  for i in range(0,10):
  	reponse=requests.get(url)
  	print(reponse.text)
  

  

3.2权重策略

在轮询策略的基础上指定轮询的几率。

• 修改default.conf

  upstream tomcats {
      server yxytomcat1:8080 weight=5;
      server yxytomcat2:8080 weight=2;
      server yxytomcat3:8080 weight=1;
  }
  ...
  

• 重启nginx容器（这步别漏了！前面漏了这步，查看结果就一直在轮询，没有切换成权重）:

  sudo docker restart yxynginx
  

  

• 使用刚才的爬虫查看负载均衡的结果

  

二、使用Docker-compose部署javaweb运行环境

1.创建如下文件

这里用的是老师给的参考项目

修改default.conf 和 docker-compose.yml两个文件

• docker-compose.yml

#所有容器都处于同一子网下；静态ip可自由分配
version: "3"   
services:     
  tomcat1:                             
    image: tomcat   
    container_name: mytomcat1
    volumes:  
     - ./webapps:/usr/local/tomcat/webapps
    networks:   #网络设置静态IP，保证在同一子网下可随意分配              
      webnet:
        ipv4_address: 15.22.0.15
  tomcat2:
     image: tomcat
     container_name: mytomcat2
     volumes:  
        - ./webapps:/usr/local/tomcat/webapps
     networks:   #网络设置静态IP，
        webnet:
          ipv4_address: 15.22.0.16
  mysql:  
    build: .   
    image: mysql
    container_name: mysql
    ports:
      - "3309:3306" 
    command: [                                    #设置编码模式
            '--character-set-server=utf8mb4',
            '--collation-server=utf8mb4_unicode_ci'
    ]
    environment:
      MYSQL_ROOT_PASSWORD: "123456"            #root密码
    networks:
      webnet:
        ipv4_address: 15.22.0.6
  nginx:
      image: nginx
      container_name: mynginx
      ports:
          - 80:2020
      volumes:
          - ./default.conf:/etc/nginx/conf.d/default.conf # 挂载配置文件
      depends_on:
            - tomcat1
            - tomcat2
      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 tomcats {            #轮询策略
    server mytomcat1:8080;
    server mytomcat2:8080;
}

server {
    listen       2020;      #nginx的监听端口
    server_name  localhost;

    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
	proxy_pass http://tomcats;      #访问nginx之后,会轮询访问代理的tomcat服务器
    }
}

其他文件内容和参考资料里的内容一样

• docker-entrypoint.sh

#!/bin/bash
mysql -uroot -p123456 << EOF    #  << EOF 必须要有
source /usr/local/grogshop.sql;

• Dockerfile

#  这个是构建MySQL的dockerfile

FROM registry.saas.hand-china.com/tools/mysql:5.7.17

# mysql的工作位置

ENV WORK_PATH /usr/local/

# 定义会被容器自动执行的目录

ENV AUTO_RUN_DIR /docker-entrypoint-initdb.d
#复制gropshop.sql到/usr/local 
COPY grogshop.sql  /usr/local/
#把要执行的shell文件放到/docker-entrypoint-initdb.d/目录下，容器会自动执行这个shell
COPY docker-entrypoint.sh  $AUTO_RUN_DIR/
#给执行文件增加可执行权限
RUN chmod a+x $AUTO_RUN_DIR/docker-entrypoint.sh

# 设置容器启动时执行的命令

#CMD ["sh", "/docker-entrypoint-initdb.d/import.sh"]

2.修改链接数据库的IP

进入项目对应目录webapps/ssmgrogshop_war/WEB-INF/classes/jdbc.properties，把IP地址修改为Linux本机IP

3.启动容器

在javaweb1文件夹中打开终端，输入如下命令

sudo docker-compose up -d 

4.浏览器访问前端页面

账号sa,密码123

可以对数据库进行各种操作

第二个实验遇到的问题

启动容器后，浏览器访问前端页面一直显示如下图所示的报错，上网查了很多资料，应该是端口冲突，试了很多种方法一直没解决，心态有点崩（还是太菜）。。。后来重写了 default.conf 和 docker-compose.yml 文件，突然就可以了，还是没搞明白为什么。。。

三、使用Docker搭建大数据集群环境

1.搭建hadoop环境

创建如下文件

拉取ubuntu镜像

sudo docker pull ubuntu 

创建并进入ubuntu容器

docker build -t ubuntu:18.04 .
docker run -it --name ubuntu ubuntu:18.04

2.ubuntu环境的初始化

安装必要工具

apt-get update
apt-get install vim # 用于修改配置文件
apt-get install ssh # 分布式hadoop通过ssh连接
/etc/init.d/ssh start # 开启sshd服务器
vim ~/.bashrc # 在文件末尾添加/etc/init.d/ssh start，实现ssd开机自启

配置ssh无密码连接本地sshd服务

ssh-keygen -t rsa # 一直按回车即可
cd ~/.ssh   
cat id_rsa.pub >> authorized_keys #这一步要在~/.ssh目录下进行

为容器安装SDK

apt install openjdk-8-jdk 

安装好后需要配置环境变量， vim ~/.bashrc打开配置文件，在最后添加

export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/
export PATH=$PATH:$JAVA_HOME/bin
export HADOOP_HOME=/usr/local/hadoop-3.1.3
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin:$JAVA_HOME/bin

使配置环境生效

source ~/.bashrc 

验证是否安装成功

java -version 

保存配置好的镜像文件

docker ps # 查看当前容器id
docker commit 容器ID ubuntu/ex4.3 # 存为镜像

安装Hadoop

先下载 Hadoop

下载地址

然后开启保存的那份镜像 ubuntu/ex4.3

docker run -it -v /home/hadoop/build:/root/build --name ubuntu-ex4.3 ubuntu/ex4.3

下载完成后，用cp命令将文件复制入共享文件夹 /home/ubuntu/hadoop/build

sudo cp /home/ubuntu/Desktop/hadoop-3.2.1.tar.gz /home/ubuntu/hadoop/build 

在打开的容器里运行

cd /root/build
tar -zxvf hadoop-3.2.1.tar.gz -C /usr/local  # 解压文件 
cd /usr/local/hadoop-3.2.1
./bin/hadoop version # 验证安装

3. 配置Hadoop集群

进入配置文件存放目录

cd /usr/local/hadoop-3.2.1/etc/hadoop 

修改core-site.xml

vim core-site.xml

#添加
<configuration>
      <property>
          <name>hadoop.tmp.dir</name>
          <value>file:/usr/local/hadoop/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

vim hdfs-site.xml

#添加
<configuration>
    <property>
        <name>dfs.namenode.name.dir</name>
        <value>file:/usr/local/hadoop/namenode_dir</value>
    </property>
    <property>
        <name>dfs.datanode.data.dir</name>
        <value>file:/usr/local/hadoop/datanode_dir</value>
    </property>
    <property>
        <name>dfs.replication</name>
        <value>3</value>
    </property>
</configuration>

修改mapred-site.xml
vim mapred-site.xml

#添加
<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.2.1</value>
    </property>
    <property>
        <name>mapreduce.map.env</name>
        <value>HADOOP_MAPRED_HOME=/usr/local/hadoop-3.2.1</value>
    </property>
    <property>
        <name>mapreduce.reduce.env</name>
        <value>HADOOP_MAPRED_HOME=/usr/local/hadoop-3.2.1</value>
    </property>
</configuration>

修改yarn-site.xml
vim yarn-site.xml

#添加
<configuration>
    <property>
        <name>yarn.nodemanager.aux-services</name>
        <value>mapreduce_shuffle</value>
    </property>
    <property>
        <name>yarn.resourcemanager.hostname</name>
        <value>master</value>
    </property>
</configuration>

保存镜像

#打开一个新的终端
docker commit 容器id ubuntu/hadoopinstalled

运行Hadoop集群

在三个终端上开启三个容器运行ubuntu/hadoopinstalled镜像，分别表示Hadoop集群中的master,slave01和slave02；

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

配置master,slave01和slave02的地址信息： 三个终端分别打开/etc/hosts,根据各自ip修改为如下形式

172.17.0.4      master
172.17.0.5      slave01
172.17.0.6      slave02

检测master是否可以连上slave01和slave02

ssh slave01
ssh slave02

修改master上workers文件，修改localhost

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

配置完成，启动集群

#在master 终端上操作
cd /usr/local/hadoop-3.1.3
bin/hdfs namenode -format      #首次启动Hadoop需要格式化
sbin/start-all.sh              #启动所有服务
jps                            #分别查看三个终端

运行Hadoop实例程序

先在hdfs上创建一个目录:

./bin/hdfs dfs -mkdir -p /user/hadoop/input

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

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

执行实例程序:

bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.2.1.jar grep /user/hadoop/input output 'dfs[a-z.]+' 

在hdfs上的output目录下查看到运行结果

./bin/hdfs dfs -cat output/*