shell脚本一键部署jdk，python，mysql，postgresql，es等组件

左手的ㄟ右手 2022-05-19 10:44 280阅读 0赞

1、根据需求，快速部署一些常用的组件。

1.  安装jdk,版本：1.8.0\_131
2.  安装python,版本：2.7.8
3.  安装mysql,版本：5.6.39
4.  安装neo4j,版本：3.1.4
5.  安装postgresql,版本：9.6.3
6.  安装node.js,版本：8.9.0
7.  安装nginx,版本：1.14.0
8.  安装elasticsearch,版本：5.2.2
9.  安装es-head

#!/bin/sh
    #存放二进制包的路径
    SOFTWARE_PATH='/opt/software'
     
    #java部分信息
    JDK_VERSION='jdk1.8.0_131'                                #jdk的版本
    
    #python部分信息
    PYTHON_VERSION='python-2.7.8'                             #python的版本
    
    #mysql安装包名
    MYSQL_VERSION='mysql-5.6.39-linux-glibc2.12-x86_64'       #mysql的版本
    
    
    #neo4j部分信息											  #neo4j的版本
    NEO4J_VERSION='neo4j-community-3.1.4' 
    
    #postgresql部分信息
    POSTGRESQL_VERSION='postgresql-9.6.3'                     #postgresql的版本
    
    
    #node.js部分信息，jdk要求1.8以上						  #node.js版本
    NODE_VERSION='node-v4.8.4' 
    
    
    #nginx部分信息
    NGINX_VERSION='nginx-1.14.0'                              #nginx的版本
    
    
    #ES部分信息
    ES_VERSION='elasticsearch-5.2.2'						  #ES的版本
    
    #es-head部分信息
    ES_HEAD_VERSION='elasticsearch-head'
    
    #获取当前脚本所在的ip
    local_ip=`ifconfig -a |head -n 2|grep inet|awk '{print $2}'`
    
     
    install_list=(
     1.安装jdk,版本：1.8.0_131
     2.安装python,版本：2.7.8
     3.安装mysql,版本：5.6.39
     4.安装neo4j,版本：3.1.4
     5.安装postgresql,版本：9.6.3
     6.安装node.js,版本：8.9.0
     7.安装nginx,版本：1.14.0
     8.安装elasticsearch,版本：5.2.2
     9.安装es-head
    )
    
    
    
    #1 步骤输出 紫色
    #2 正确输出 绿色
    #3 错误输出 红色
    #4 提示输出 蓝色
    #5 警告输出 黄色
    #根据不同的颜色打印出提示信息
    function echo_fun(){
      if [ $# -ge 2 ];then
          params_num=$1
          shift 1
          params_mes=$@
      else
          echo_fun 3 请至少输入两个参数 echo_fun ..
          exit
      fi
      case $params_num in
            1)
            echo -e "\n\033[35;40;1m ****************************** ${params_mes} ******************************\033[0m\r\n"
            ;;
            2)
            echo -e "\033[32;40;1m ${params_mes}\033[0m\r\n"
            ;;
            3)
            echo -e "\n\033[31;40;1m ${params_mes}\033[0m\r\n"
            ;;
            4)
            echo -e "\033[36;40;1m ${params_mes}\033[0m\r\n"
            ;;
            5)
            echo -e "\033[33;40;1m ${params_mes} \033[0m\r\n"
            ;;
            *)
            echo_fun 3 参数异常第一个参数应为1,2,3,4,5
            ;;
       esac
    }
    
    
    function echo_list(){
        echo_fun 5 安装目录如下,请选择安装步骤:
        for (( i=0;i<${#install_list[@]};i++ ))
        do
          echo_fun 4 ${install_list[i]}
        done
    }
    
     
    function yn_install(){
       read -p "选择安装项[1-9]: " num
       case $num in
            1)
            echo_fun 1  ${install_list[0]}
            step_fun_1
            ;;
            2)
            echo_fun 1  ${install_list[1]}
            step_fun_2
            ;;
            3)
            echo_fun 1  ${install_list[2]}
            step_fun_3
            ;;
            4)
            echo_fun 1  ${install_list[3]}
            step_fun_4
            ;;
            5)
            echo_fun 1  ${install_list[4]}
            step_fun_5
            ;;
            6)
            echo_fun 1  ${install_list[5]}
            step_fun_6
            ;;
            7)
            echo_fun 1  ${install_list[6]}
            step_fun_7
            ;;
            8)
            echo_fun 1  ${install_list[7]}
            step_fun_8
            ;;
            9)
            echo_fun 1  ${install_list[8]}
            step_fun_9
            ;;
            *)
            echo_fun 3 数字应该在1-9之间
            exit
            ;;
       esac
    }
    
    #获取安装机器ip
    function get_host_list(){
    	echo_fun 4 请输入需要安装的机器，多个ip之间用逗号隔开
    	read -p "host_list=" host_list
    	echo ''
    	str=${host_list//,/ }
    	host_ip=($str)
    }
    
    
    #检查安装目录是否存在,存在则退出程序，以防误安装
    function check_cluster_catalog_exist(){
       num=0
       for ip in ${host_ip[*]}
       do
          num=$(ssh $ip test -d $1 &&  echo 1 || echo 0 )
          if [ $num -eq 1 ];then
            echo_fun 3 "$ip机器上的$2目录存在,请注意检查" 
            exit
          fi
    done
    }
    
    
    #检查用户是否存在，不在就开始创建
    function check_cluster_etc_profile(){
    
       cluster_path_num=0
       for ip in ${host_ip[*]}
       do
         cluster_path_num=$(ssh $ip cat /etc/profile |grep -w $1 |wc -l )
         if [ ${cluster_path_num} -ge 1 ];then
            echo_fun 5 $ip机器上$1环境变量已经配置,请检查准确性
            read -p "正确与否[y/n]：" answer		
    	    echo ''
    	    if [ $answer == 'y' ];then
              echo_fun 4 $ip机器上环境变量已经存在,且配置正确
            fi
    	
            if [ $answer == 'n' ];then
              exit
            fi
      
         else
            $2 ${ip}    #创建用户其中$2是函数
         fi
    done
    }
    
    
    #解压二进制包，并设置软连接
    function extract_pkg(){
        cd $1  
        tar -xf $2.tar.gz  -C  $3 
        ln -s $3/$2   $3/$4
    }
     
    #同步安装包和软连接到其他的集群机器上
    function rsync_pkg(){
        sleep 1s
        cd $1 
        for ((i=0;i<${#host_ip[*]};i++))
        do
           rsync -av $2  $3  ${host_ip[i]}:$1  >/dev/null 2>&1
           echo_fun 2 ${host_ip[i]}机器同步成功
        done 
    }
     
    #如果本机上不需要安装，则删除解压后的包 
    function remove_pkg(){
    
    for ((i=0;i<${#host_ip[*]};i++))
       do
          if [ ${local_ip} == ${host_ip[i]} ];then
             remove_num=1
          fi
       done
    }
    
    
    #授权
    function chown_user(){
       for ip in ${host_ip[*]}
       do
          ssh $ip "cd $1;chown -R $2:$3 $4"
       done
    }
    
    #检查用户是否存在，不在就开始创建
    function check_cluster_exist_user(){
       cluster_num_use=0
       for ip in ${host_ip[*]}
       do
          echo_fun 4 检查$ip机器上的$1用户是否存在
          cluster_num_user=$(ssh $ip cat /etc/passwd|grep -w $1|wc -l )
          if [ ${cluster_num_user} -ge 1 ];then
              echo_fun 5 $ip机器已经$1用户已经存在,请检查
              read -p "是否继续下一步[y/n]：" answer		
              if [ $answer == 'n' ];then
                exit
              fi	
         else
              echo_fun 4  ${ip}机器添加用户,并设置密码
              ssh -Tq ${ip} <<remotessh
                 useradd -d /home/$1 $1
                 expect -c"
                 spawn passwd $1
                 expect {
                     \"*yes/no*\" {send \"yes\r\";exp_continue}
                     \"*New password:*\" {send \"$2\r\";exp_continue}
                     \"*Retype new password:*\" {send \"$2\r\";exp_continue}
                     }"
                     exit
    remotessh
          fi
          echo -e '\n'
        done
    }
    
    #检查安装的组件是否存在
    function check_cluster_package(){
        for ip in ${host_ip[*]}
        do
           cluster_package_num=$(ssh $ip rpm -qa|grep $1|wc -l )
           if [ ${cluster_package_num} -ge 1 ];then
              echo_fun 2 "$ip机器上的$1组件存在,继续下一步" 
           else
              echo_fun 5 $ip机器上缺少$1的依赖包,安装依赖
              ssh $ip "yum install -y $1 >/dev/null 2>&1"
           fi
        done
    }
    
    
    #jdk环境变量
    function etc_jdk_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport JAVA_HOME=${JDK_INSTALL_PATH}/java\nexport PATH=\${JAVA_HOME}/bin:\$PATH'>> /etc/profile
          source /etc/profile
          exit
    remotessh
    }
    
    #python的环境变量
    function etc_python_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport PYTHON_HOME=${PYTHON_INSTALL_PATH}/python\nexport PATH=\${PYTHON_HOME}/bin:\$PATH'>> /etc/profile
          source /etc/profile
          exit
    remotessh
    }
    
    #neo4j的环境变量
    function etc_neo4j_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport NEO4J_HOME=${NEO4J_INSTALL_PATH}/neo4j\nexport PATH=\${NEO4J_HOME}/bin:\$PATH'>> /etc/profile
          source /etc/profile
          exit
    remotessh
    }
    
    
    #psql环境变量
    function etc_psql_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport POSTGRESQL_HOME=${POSTGRESQL_INSTALL_PATH}/postgresql\nexport PATH=\${POSTGRESQL_HOME}/bin:\$PATH\nexport PGDATA=\${POSTGRESQL_HOME}/data\n'>> /etc/profile
          source /etc/profile
          exit
    remotessh
    }
    
    #node.js环境变量
    function etc_node_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport NODE_HOME=${NODE_INSTALL_PATH}/node\nexport PATH=\${NODE_HOME}/bin:\$PATH'>> /etc/profile
          source /etc/profile
          exit
    remotessh
    }
    
    
    #nginx环境变量
    function etc_nginx_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport NGINX_HOME=${NGINX_INSTALL_PATH}/nginx\nexport PATH=\${NGINX_HOME}/sbin:\$PATH'>> /etc/profile
          source /etc/profile
          exit
    remotessh
    }
    
     
    #es环境变量
    function etc_es_profile(){
       echo_fun 4 配置$ip机器上的环境变量
       ssh -Tq root@$1 <<remotessh
          echo -e '\nexport ES_HOME=${ES_INSTALL_PATH}/elasticsearch\nexport PATH=\${ES_HOME}/bin:\$PATH'>> /etc/profile 
          source /etc/profile
          exit
    remotessh
    }
     
    # ------------------------------------------------第一步jdk----------------------------------------------------
    #安装jdk
    function step_fun_1(){
       #获取安装机器ip
       get_host_list
    
       echo_fun 4 请输入java安装位置如[/opt]
       read -p "jdk_install_path=" JDK_INSTALL_PATH
       echo ''
    
       echo_fun 5  检查java安装目录是否存在
    
       #循环检查/opt/java目录是否存在
       check_cluster_catalog_exist ${JDK_INSTALL_PATH}/java java
     
    
       if [ $num -eq 0 ];then
         #解压jdk包
         echo_fun 4 解压jdk二进制包,并创建软连接
         extract_pkg ${SOFTWARE_PATH}  ${JDK_VERSION}  ${JDK_INSTALL_PATH} java
    
         #同步
         echo_fun 4 同步jdk目录和软连接到其他的集群机器上
         rsync_pkg ${JDK_INSTALL_PATH}  java  ${JDK_VERSION} 
    
         #删除
         remove_num=0
         remove_pkg  ${JDK_INSTALL_PATH} ${JDK_VERSION}
         if [ ${remove_num} -ne 1 ];then
       	   cd ${JDK_INSTALL_PATH}
       	   rm -rf ${JDK_INSTALL_PATH}/java  ${JDK_INSTALL_PATH}/${JDK_VERSION}
         fi
       fi 
    
    
        echo_fun 4 检查环境变量
        check_cluster_etc_profile ${JDK_INSTALL_PATH}/java  etc_jdk_profile
    }
     
    
    # ------------------------------------------------第二步python---------------------------------------------------- 
    
    #安装python
    function step_fun_2(){
    
       #获取安装机器ip
       get_host_list
    
       echo_fun 4 请输入python安装位置如[/opt]
       read -p "python_install_path="  PYTHON_INSTALL_PATH
       echo ''
       echo_fun 4  检查python安装目录是否存在
       #循环检查python目录是否存在
       check_cluster_catalog_exist ${PYTHON_INSTALL_PATH}/python  python
     
     
       if [ $num -eq 0 ];then
         #解压python包
         echo_fun 4 解压python二进制包,并创建软连接
         extract_pkg ${SOFTWARE_PATH}  ${PYTHON_VERSION}  ${PYTHON_INSTALL_PATH} python
    
         #同步
         echo_fun 4 同步python目录和软连接到其他的集群机器上
         rsync_pkg ${PYTHON_INSTALL_PATH}  python  ${PYTHON_VERSION} 
    
         #删除
         remove_num=0
         remove_pkg  ${PYTHON_INSTALL_PATH} ${PYTHON_VERSION}
         if [ ${remove_num} -ne 1 ];then
       	    cd ${PYTHON_INSTALL_PATH}
       	    rm -rf ${PYTHON_INSTALL_PATH}/python  ${PYTHON_INSTALL_PATH}/${PYTHON_VERSION}
         fi
       fi 
     
       echo_fun 4 检查环境变量
       check_cluster_etc_profile ${PYTHON_INSTALL_PATH}/python   etc_python_profile 
    }
    
    
    
    #---------------------------------------------------------第三步---------------------------------------------------- 
    #本地解压,发送到主从机器
    function tar_mysql(){
    	
       cd ${SOFTWARE_PATH}
       tar -xf ${MYSQL_VERSION}.tar.gz  -C  ${MYSQL_INSTALL_PATH}
       ln -s ${MYSQL_INSTALL_PATH}/${MYSQL_VERSION}   ${MYSQL_INSTALL_PATH}/mysql
       cd ${MYSQL_INSTALL_PATH}
       for ((i=0;i<${#host_ip[*]};i++))
       do
          rsync -av mysql  ${MYSQL_VERSION}  ${host_ip[i]}:${MYSQL_INSTALL_PATH} >/dev/null 2>&1
          echo_fun 2 ${host_ip[i]}机器mysql安装目录已经同步完毕
       done
    
       #删除
       remove_num=0
       remove_pkg  ${MYSQL_INSTALL_PATH} ${MYSQL_VERSION}
       if [ ${remove_num} -ne 1 ];then
          cd ${MYSQL_INSTALL_PATH}
          rm -rf ${MYSQL_INSTALL_PATH}/mysql  ${MYSQL_INSTALL_PATH}/${MYSQL_VERSION}
       fi
    }
    
    #修改单机mysql上/etc/my.cnf配置文件
    function  alter_mysql_file(){
       ssh -Tq $1 <<remotessh
    	  rm -rf /etc/my.cnf
    	  cd  ${MYSQL_INSTALL_PATH}/mysql
    	  cp support-files/my-default.cnf  /etc/my.cnf
    	  cp support-files/mysql.server  /etc/init.d/mysql.server
    	  sed -i '/mysqld/a\datadir=/usr/local/mysql/data' /etc/my.cnf
    	  sed -i '/mysqld/a\socket=/tmp/mysql.sock' /etc/my.cnf
    	  sed -i '/mysqld/a\user=mysql' /etc/my.cnf
    	  exit
    remotessh
    }
    
    
    
    #修改主机器上/etc/my.cnf
    function  alter_master_file(){
      ssh -Tq $1 <<remotessh
    	 rm -rf /etc/my.cnf
    	 cd  ${MYSQL_INSTALL_PATH}/mysql
    	 cp support-files/my-default.cnf  /etc/my.cnf
    	 cp support-files/mysql.server  /etc/init.d/mysql.server
    	 sed -i '/mysqld/a\datadir=/usr/local/mysql/data' /etc/my.cnf
    	 sed -i '/mysqld/a\socket=/tmp/mysql.sock' /etc/my.cnf
    	 sed -i '/mysqld/a\user=mysql' /etc/my.cnf
    	 sed -i '/mysqld/a\log-bin-index=master-bin.index' /etc/my.cnf
    	 sed -i '/mysqld/a\log-bin=master-bin' /etc/my.cnf
    	 sed -i '/mysqld/a\server-id=1' /etc/my.cnf
    	 exit
    remotessh
    }
    
    
    
    #修改从机器上/etc/my.cnf
    function  alter_slave_file(){
      ssh -Tq $1 <<remotessh
    	 rm -rf /etc/my.cnf
    	 cd ${MYSQL_INSTALL_PATH}/mysql
    	 cp support-files/my-default.cnf  /etc/my.cnf
    	 cp support-files/mysql.server  /etc/init.d/mysql.server
    	 sed -i '/mysqld/a\datadir=/usr/local/mysql/data' /etc/my.cnf
    	 sed -i '/mysqld/a\socket=/tmp/mysql.sock' /etc/my.cnf
    	 sed -i '/mysqld/a\user=mysql' /etc/my.cnf
    	 sed -i '/mysqld/a\relay-log=slave-relay-bin' /etc/my.cnf
    	 sed -i '/mysqld/a\relay-log-index=slave-relay-bin.index' /etc/my.cnf
    	 sed -i '/mysqld/a\server-id=2' /etc/my.cnf
    	 exit
    remotessh
    }
    
    
    #初始化数据库
    function init_mysql(){
      ssh -Tq $1 <<remotessh
         cd ${MYSQL_INSTALL_PATH}/mysql
    	 scripts/mysql_install_db --user=mysql  >/dev/null 2>&1
    	 /etc/init.d/mysql.server start
    	 exit
    remotessh
    }
    
    
    
    #mysql主从复制
    function mysql_ha(){
    
       echo_fun 5 mysql的主从安装开始
    
       #获取安装机器ip
       get_host_list
       echo ''
       echo_fun 4 请输入mysql安装位置如[/usr/local]
       read -p "mysql_install_path=" MYSQL_INSTALL_PATH
       echo ''
    
       #检查主机器mysql安装目录是否存在
       check_cluster_catalog_exist ${MYSQL_INSTALL_PATH}/mysql mysql
    
       #安装依赖
       check_cluster_package autoconf
       check_cluster_package libaio-devel
       
    
    
       echo_fun 5 请输入mysql的属组用户
       read -p "mysql_user=" MYSQL_USER
       echo ''
       check_cluster_exist_user ${MYSQL_USER}
     
       if [ ${cluster_num_user} -eq 0 ]; then
         echo_fun  4 给mysql用户输入密码
         read -p "mysql_password=" MYSQL_USER_PASSWD
         echo ''
         add_cluster_user ${MYSQL_USER} ${MYSQL_USER_PASSWD}
       fi
     
    
       #开始安装
       echo_fun 4 本机解压，然后发送到主从机器上，时间较长请耐心等待
       tar_mysql 
    
       #授权
       chown_user ${MYSQL_INSTALL_PATH} ${MYSQL_USER} ${MYSQL_USER} ${MYSQL_INSTALL_PATH}/mysql*
     
    
       echo_fun 4 修改主mysql的配置文件
       alter_master_file ${host_ip[0]}
    
       echo_fun 2 主机器配置文件修改完毕
    
       echo_fun 4 修改从mysql的配置文件
       alter_slave_file ${host_ip[1]}
       echo_fun 2 从机器配置文件修改完毕
    
     
       echo_fun 4 检查环境变量
       check_cluster_etc_profile ${MYSQL_INSTALL_PATH}/mysql
    
       if [ ${cluster_path_num} -lt 1 ];then
          echo_fun 4 配置环境变量
          for ((i=0;i<${#host_ip[*]};i++))
          do
             echo_fun 4 配置${host_ip[i]}机器上的环境变量
             ssh -Tq root@${host_ip[i]} <<remotessh
             echo -e '\nexport MYSQL_HOME=${MYSQL_INSTALL_PATH}/mysql\nexport PATH=\${MYSQL_HOME}/bin:\$PATH'>> /etc/profile 
             source /etc/profile
             exit
    remotessh
          done
       fi 
    
       #初始化mysql,并启动
       echo_fun 4 初始化主mysql，并启动主mysql
       init_mysql ${host_ip[0]}
       echo ''
    
       echo_fun 4 初始化从mysql，并启动从mysql
       init_mysql ${host_ip[1]}
       echo ''
    
    
       #主mysql设置密码和配置
       echo_fun 4  初始化主mysql密码，创建同步master端数据库的用户
    
       echo_fun 5 请输入root用户密码
       read -p "root_passwd=" root_passwd
       echo ''
    
       echo_fun 5 输入同步master数据库到slave端用户
       read -p "replication_user=" r_user
       echo ''
    
       echo_fun 5 输入用户密码
       read -p "replication_passwd=" r_passwd
    
       ssh -Tq ${host_ip[0]}<<remotessh
       mysql  -uroot <<EOF 
       set password = password("${root_passwd}");
       GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '${root_passwd}';
       GRANT ALL PRIVILEGES ON *.* TO 'root'@localhost IDENTIFIED BY '${root_passwd}';
       GRANT REPLICATION SLAVE ON *.* to '${r_user}'@'%' identified by '${r_passwd}';
       flush privileges;
    EOF
    remotessh
    
       #postion地址，注意这里不能用$ip ""格式 也不能用awk指令，不知道为什么
       postion_num=$(ssh -Tq ${host_ip[0]} <<EOF
          mysql -uroot -p${root_passwd} -e 'show master status\G' 2>/dev/null|grep Position |cut -f2 -d :
    EOF
    )
       echo_fun 5 pos地址：${postion_num}
    
       #bin-log文件名 
       log_name=$(ssh -Tq ${host_ip[0]} <<EOF
          mysql -uroot -p${root_passwd} -e 'show master status\G' 2>/dev/null|grep File |cut -f2 -d :
    EOF
    )
       echo_fun 5 bin-log文件名：${log_name}
    
       #从mysql设置密码和配置
       ssh -Tq ${host_ip[1]} <<remotessh
       mysql  -uroot <<EOF
         set password = password("${root_passwd}");
         GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '${root_passwd}';
         GRANT ALL PRIVILEGES ON *.* TO 'root'@localhost IDENTIFIED BY '${root_passwd}';
         change master to master_host='${host_ip[0]}',master_port=3306,master_user='${r_user}',master_password='${r_passwd}', master_log_file='${log_name}',master_log_pos=${postion_num};
         start slave;
         EOF
    remotessh
    
    
       #检查是否主从复制搭建成功
       running_num=$(ssh -Tq ${host_ip[1]} <<eof
         mysql -uroot -p${root_passwd} -e "show slave status\G" 2>/dev/null |grep "Running: Yes"|wc -l
    eof
    )
    
       if [ $running_num -eq 2 ];then
          echo_fun 2 "mysql主从复制搭建成功"     
       else
          echo_fun 3  "mysql主从搭建失败"
       fi
    
    }
    
       #mysql单机部署
       function mysql_single(){
    
       echo_fun 5 mysql的单机安装开始
    
       #获取安装机器ip
       get_host_list
       echo ''
       echo_fun 4 请输入mysql安装位置如[/usr/local]
       read -p "mysql_install_path=" MYSQL_INSTALL_PATH
       echo ''
    
       #检查主机器mysql安装目录是否存在
       check_cluster_catalog_exist ${MYSQL_INSTALL_PATH}/mysql mysql
       #安装依赖
       check_cluster_package autoconf
       check_cluster_package libaio-devel
    
       echo_fun 5 请输入mysql的属组用户
       read -p "mysql_user=" MYSQL_USER
       echo ''
       check_cluster_exist_user ${MYSQL_USER}
     
       if [ ${cluster_num_user} -eq 0 ]; then
         echo_fun  4 给mysql用户输入密码
         read -p "mysql_password=" MYSQL_USER_PASSWD
         echo ''
         add_cluster_user ${MYSQL_USER} ${MYSQL_USER_PASSWD}
       fi
     
    
       #开始安装
        echo_fun 4 本机解压，然后发送到被安装机器上
        tar_mysql 
    
       #授权
        chown_user ${MYSQL_INSTALL_PATH} ${MYSQL_USER} ${MYSQL_USER} ${MYSQL_INSTALL_PATH}/mysql*
     
        echo_fun 4 修改mysql的配置文件
        alter_mysql_file ${host_ip[0]}
        echo_fun 2 mysql配置文件修改完毕
    
    
        echo_fun 4 检查环境变量
        check_cluster_etc_profile ${MYSQL_INSTALL_PATH}/mysql
    
        if [ ${cluster_path_num} -lt 1 ];then
          echo_fun 4 配置环境变量
          for ((i=0;i<${#host_ip[*]};i++))
          do
            echo_fun 4 配置${host_ip[i]}机器上的环境变量
            ssh -Tq root@${host_ip[i]} <<remotessh
            echo -e '\nexport MYSQL_HOME=${MYSQL_INSTALL_PATH}/mysql\nexport PATH=\${MYSQL_HOME}/bin:\$PATH'>> /etc/profile 
            source /etc/profile
            exit
    remotessh
          done
        fi 
    
       #初始化mysql,并启动
       echo_fun 4 初始化mysql，并启动
       init_mysql ${host_ip[0]}
       echo ''
    
    
       #mysql设置密码和配置 
       echo_fun 4  初始化主mysql密码
    
       echo_fun 5 请输入root用户密码 
       read -p "root_passwd=" root_passwd
       echo ''
    
       ssh -Tq ${host_ip[0]}<<EOF
       mysql  -uroot <<eof 
         set password = password("${root_passwd}");
         GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '${root_passwd}';
         GRANT ALL PRIVILEGES ON *.* TO 'root'@localhost IDENTIFIED BY '${root_passwd}';
         flush privileges;
    eof
    EOF
    
        if [ $? -eq 0 ];then
           echo_fun 4 初始化密码成功
      
        fi
    
    }
    
    #mysql的安装
    function step_fun_3(){
       echo_fun 4 单机部署选择1，主从部署选择2
       read -p "choice=" choice
       echo ''
       if [ ${choice} -eq 1 ]; then
          mysql_single  
       else
    	  mysql_ha   
       fi
    }
    
    
    #------------------------------------------------第四步-----------------------------------------------------------
    
    #echo_fun 4 修改neo4j配置文件内容
    function alter_neo4j_config(){
       for ip in ${host_ip[*]}
       do
       ssh -Tq ${ip} <<remotessh
       cd ${NEO4J_INSTALL_PATH}/neo4j/conf/
       #sed -i '/#dbms.directories.data/s/^#//' neo4j.conf
       #sed -i '/#dbms.directories.plugins/s/^#//' neo4j.conf
       #sed -i '/#dbms.directories.certificates/s/^#//' neo4j.conf
       #sed -i '/#dbms.directories.logs/s/^#//' neo4j.conf
       #sed -i '/#dbms.directories.lib/s/^#//' neo4j.conf
       #sed -i '/#dbms.directories.run/s/^#//' neo4j.conf
       #sed -i '/#dbms.connectors.default_listen_address/s/^#//' neo4j.conf
       #sed -i '/#dbms.connector.bolt.tls_leve/s/^#//' neo4j.conf
       sed -i 's/dbms.connector.bolt.listen_address=172.24.8.86:7687/dbms.connector.bolt.listen_address='"${ip}"':7687/g' neo4j.conf
       sed -i 's/dbms.connector.http.listen_address=172.24.8.86:7474/dbms.connector.http.listen_address='"${ip}"':7474/g' neo4j.conf
       sed -i 's/dbms.connector.https.listen_address=172.24.8.86:7473/dbms.connector.https.listen_address='"${ip}"':7473/g' neo4j.conf
       #sed -i '/dbms.security.allow_csv_import_from_file_urls=true/s/^#//' neo4j.conf
       #sed -i '/dbms.shell.enabled/s/^#//' neo4j.conf
       #sed -i '/dbms.shell.port=1337/s/^#//' neo4j.conf
       sed -i 's/dbms.shell.host=172.24.8.86/dbms.shell.host='"${ip}"'/g' neo4j.conf
    remotessh
       done
    }
    
    #启动neo4j
    function start_neo4j(){
       echo_fun 4 启动neo4j进程
       for ip in ${host_ip[*]}
       do
         ssh -Tq ${ip} <<remotessh
         su - ${NEO4J_USER} <<EOF
         cd ${NEO4J_INSTALL_PATH}/neo4j
         nohup ./bin/neo4j start >/home/${NEO4J_USER}/neo4j.log 2>&1
    EOF
        exit
    remotessh
    
       #判断进程是否存在
       neo4j_pid_num=$(ssh ${ip} "ps -ef |grep neo4j|grep -v grep|wc -l")
       if [ ${neo4j_pid_num} -ge 1 ];then
          echo_fun 2  ${ip}机器上的neo4j has started.... 
       fi
       done
    }
     
    
    function step_fun_4(){
     
       #获取安装机器ip
       get_host_list
    
       echo_fun 4 请输入neo4j安装位置如[/opt]
       read -p "neo4j_install_path=" NEO4J_INSTALL_PATH
       echo ''
    
       echo_fun 4 检查neo4j安装目录是否存在
    
       #循环检查neo4j目录是否存在
       check_cluster_catalog_exist ${NEO4J_INSTALL_PATH}/${NEO4J_VERSION} neo4j
    
     
       echo_fun 5 请输入neo4j的属组用户
       read -p "neo4j_user=" NEO4J_USER
       echo ''
       
       echo_fun  4 给neo4j用户输入密码
       read -p "neo4j_password=" NEO4J_PASSWD
       echo ''
      
       check_cluster_exist_user  ${NEO4J_USER} ${NEO4J_PASSWD}
    
       if [ $num -eq 0 ];then
         #解压neo4j包
         echo_fun 4 解压neo4j二进制包,并创建软连接
         extract_pkg ${SOFTWARE_PATH}  ${NEO4J_VERSION}  ${NEO4J_INSTALL_PATH} neo4j
    
         #同步
         echo_fun 4 同步neo4j目录和软连接到安装机器上
         rsync_pkg ${NEO4J_INSTALL_PATH}  neo4j  ${NEO4J_VERSION}
       
         #修改配置文件
         echo_fun 4 修改neo4j配置文件内容
         alter_neo4j_config
       
         #删除
         remove_num=0
         remove_pkg  ${NEO4J_INSTALL_PATH} ${NEO4J_INSTALL_VERSION}
         if [ ${remove_num} -ne 1 ];then
           cd ${NEO4J_INSTALL_PATH}
           rm -rf ${NEO4J_INSTALL_PATH}/neo4j  ${NEO4J_INSTALL_PATH}/${NEO4J_VERSION}
         fi
       fi 
         #授权
         chown_user ${NEO4J_INSTALL_PATH} ${NEO4J_USER} ${NEO4J_USER} ${NEO4J_INSTALL_PATH}/neo4j*
    
         echo_fun 4 检查环境变量
         check_cluster_etc_profile  ${NEO4J_INSTALL_PATH}/neo4j  etc_neo4j_profile
     
         #启动
         start_neo4j
    }
    
    #-------------------------------------------------------第五步--------------------------------------------------
    #编译，安装
    function configure_psql(){
       for ip in ${host_ip[*]}
       do
         echo_fun 4  ${ip}机器上的psql编译安装，时间较长，耐心等待....
         ssh -Tq ${ip}<<remotessh
         cd ${POSTGRESQL_INSTALL_PATH}/${POSTGRESQL_VERSION}
         ./configure --prefix=${POSTGRESQL_INSTALL_PATH}/postgresql >/dev/null 2>&1
         sleep 2s
         make  >/dev/null 2>&1 && make install >/dev/null 2>&1
    remotessh
       done
    }
    
    
    #初始化psql
    function init_psql(){
       for ip in ${host_ip[*]}
       do
       ssh -Tq ${ip} <<remotessh
       su - ${psql_user} <<EOF
        ${POSTGRESQL_INSTALL_PATH}/postgresql/bin/initdb  >/dev/null 2>&1
        sleep 5s
    EOF
    remotessh
    done
    }
    
    function alter_sqpl_config(){
       for ip in ${host_ip[*]}
       do
       ssh -Tq ${ip} <<remotessh
          cd ${POSTGRESQL_INSTALL_PATH}/postgresql/data
          sed -i 's/127.0.0.1\/32            trust/0.0.0.0\/0               md5/g' pg_hba.conf
    	  sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '*'/g" postgresql.conf
          sed -i 's/#port = 5432/port = 5432/g' postgresql.conf
    remotessh
       done
    }
    
    
    #启动postgresql
    function start_psql(){
    
       for ip in ${host_ip[*]}
       do
       ssh -Tq ${ip} <<remotessh
       su - ${psql_user} <<EOF
         pg_ctl -D ${POSTGRESQL_INSTALL_PATH}/postgresql/data -l logfile start
    EOF
         exit
    remotessh
       
       #检查postgresql启动进程
       echo_fun 4 检查postgresql进程
       psql_pid_num=$(ssh ${ip} "ps -ef |grep ${POSTGRESQL_INSTALL_PATH}/postgresql/data|grep -v grep|wc -l")
       if [ ${psql_pid_num} -ge 1 ];then
         echo_fun 2 ${ip}机器上的postgresql has started....
       fi
       done
    }
     
    function step_fun_5(){
     
       #获取安装机器ip
       get_host_list
       echo ''
    
       echo_fun 4 请输入postgresql安装位置如[/opt]
       read -p "psql_install_path=" POSTGRESQL_INSTALL_PATH
       echo ''
    
       echo_fun 4 检查postgresql目录是否存在
       #循环检查/opt/postgresql目录是否存在
       check_cluster_catalog_exist ${POSTGRESQL_INSTALL_PATH}/postgresql postgresql
    
       echo_fun 5  建议创建一个[postgres]用户，用来启动postgresql
       read -p "psql_user=" psql_user
       echo ''
       echo_fun  4 给${psql_user}用户输入密码
       read -p "psql_passwd=" psql_passwd
       echo ''
       check_cluster_exist_user ${psql_user} ${psql_passwd}
    
    
    
       if [ $num -eq 0 ];then
      
         #解压,并修改配置文件
         echo_fun 4 解压postgresql二进制包
         cd ${SOFTWARE_PATH}
         tar -xf  ${POSTGRESQL_VERSION}.tar.gz -C ${POSTGRESQL_INSTALL_PATH}
      
         #同步
         echo_fun 4 同步postgresql目录到其安装机器上
         cd ${POSTGRESQL_INSTALL_PATH}
         for ip in ${host_ip[*]}
         do
           scp -r ${POSTGRESQL_VERSION}  ${ip}:${POSTGRESQL_INSTALL_PATH}  >/dev/null 2>&1
         done
    
         #删除解压的包
         cd ${POSTGRESQL_INSTALL_PATH}
         rm -rf ${POSTGRESQL_INSTALL_PATH}/${POSTGRESQL_VERSION}
       fi 
    
    
       #安装依赖
       echo_fun 4 解决安装依赖
       check_cluster_package readline-devel
       check_cluster_package zlib-devel
    
       #编译安装
       echo_fun 4 编译安装
       configure_psql
    
    
       #配置环境变量和指定PGDATA位置
       check_cluster_etc_profile  ${POSTGRESQL_INSTALL_PATH}/postgresql  etc_psql_profile
     
    
       #授权
       chown_user ${POSTGRESQL_INSTALL_PATH} ${psql_user} ${psql_user} ${POSTGRESQL_INSTALL_PATH}/postgresql*
     
       #初始化psql
       echo_fun 4 初始化psql
       init_psql
    
       #修改配置文件
       echo_fun 4 修改配置文件
       alter_sqpl_config
    
    
       #启动psql
       echo_fun 4 启动postgresql
       start_psql
    }
    
    #---------------------------------------------------------第六步------------------------------------------------
    
    #安装node.js
    function step_fun_6(){
    
       #获取安装机器ip
       get_host_list
    
    
       echo_fun 4 请输入node.js安装位置如[/opt]
    
       read -p "node_install_path="  NODE_INSTALL_PATH
       echo ''
       echo_fun 4  检查node.js安装目录是否存在
       #检查node目录是否存在
       check_cluster_catalog_exist ${NODE_INSTALL_PATH}/node  node
    
    
       if [ $num -eq 0 ];then
      
        #解压,设置软连接
         echo_fun 4 解压node.js二进制包,并创建软连接
         extract_pkg ${SOFTWARE_PATH} ${NODE_VERSION} ${NODE_INSTALL_PATH} node
        #同步
         echo_fun 4 同步node目录和软连接到其安装机器上
         rsync_pkg ${NODE_INSTALL_PATH} ${NODE_VERSION}  node
    
        #删除
         remove_num=0
         remove_pkg  ${NODE_INSTALL_PATH} ${NODE_VERSION}
         if [ ${remove_num} -ne 1 ];then
       	    cd ${NODE_INSTALL_PATH}
       	    rm -rf ${NODE_INSTALL_PATH}/node  ${NODE_INSTALL_PATH}/${NODE_VERSION}
         fi
       fi 
    
       echo_fun 4 检查环境变量
       check_cluster_etc_profile  ${NODE_INSTALL_PATH}/node  etc_node_profile  
    
       for ((i=0;i<${#host_ip[*]};i++))
       do
          node_v=$(ssh ${host_ip[i]} "${NODE_INSTALL_PATH}/node/bin/node -v")
          if [ $? -eq 0 ];then
             echo_fun 2 ${host_ip[i]}机器node.js安装成功
          fi
          echo_fun 5 "node.js的版本号为:${node_v}"
       done
    }
    
    #---------------------------------------------------------第七步------------------------------------------------
     
    #初始化ngxin的二进制包。
    function init_nginx(){
      for ip in ${host_ip[*]}
      do
        ssh -Tq ${ip}<<remotessh
        echo_fun 4 ${ip}机器进行nginx编译安装，时间较长耐心等待....
        cd ${NGINX_INSTALL_PATH}/${NGINX_VERSION}
       ./configure --prefix=./configure --prefix=${NGINX_INSTALL_PATH}/nginx --user=$1 --group=$2 --error-log-path=/usr/local/nginx/error.log --pid-path=/usr/local/nginx/nginx.pid --http-log-path=/usr/local/nginx/access.log --with-debug --with-http_stub_status_module >/dev/null 2>&1
        make >/dev/null 2>&1 && make install >/dev/null 2>&1
    remotessh
      done
    }
     
     
    function start_nginx(){
       echo_fun 4 启动nginx
       for ip in ${host_ip[*]}
       do
        ssh -Tq ${ip} <<remotessh
        cd ${NGINX_INSTALL_PATH}/nginx
        nohup nginx >/home/${NGINX_USER}/nginx.log 2>&1
        exit
    remotessh
    
       #判断进程是否存在
       nginx_pid_num=$(ssh ${ip} "ps -ef |grep nginx|grep -v grep|wc -l")
       if [ ${nginx_pid_num} -ge 1 ];then
         echo_fun 2 ${ip}机器上的nginx has started.... 
       fi
       done
    }
     
     
    #nginx的部署
    function step_fun_7(){
     
      #获取安装机器ip
      get_host_list
    
      echo_fun 4 请输入nginx安装位置如[/usr/local]
      read -p "nginx_install_path=" NGINX_INSTALL_PATH
      echo ''
    
      echo_fun 4 检查nginx安装目录是否存在
    
      #循环检查nginx目录是否存在
      check_cluster_catalog_exist ${NGINX_INSTALL_PATH}/${NGINX_VERSION} nginx
    
    
      echo_fun 5 请输入nginx的work进程用户
      read -p "nginx_user=" NGINX_USER
      echo ''
    
      echo_fun  4 给nginx用户输入密码
      read -p "nginx_password=" NGINX_PASSWD
      echo ''
        
      check_cluster_exist_user ${NGINX_USER}  ${NGINX_PASSWD}
    
    
      if [ $num -eq 0 ];then
        #解压nginx包
        echo_fun 4 解压nginx二进制包,并同步到其安装机器
        cd ${SOFTWARE_PATH}
        tar -xf  ${NGINX_VERSION}.tar.gz 
        for ip in ${host_ip[*]}
        do
           scp -r ${NGINX_VERSION} root@${ip}:${NGINX_INSTALL_PATH}  >/dev/null 2>&1
        done
        #删除解压的包
        cd ${SOFTWARE_PATH}
        rm -rf ${NGINX_VERSION}
      fi 
    
    
       #安装依赖
       check_cluster_package openssl-devel
       check_cluster_package pcre-devel
       check_cluster_package zlib-devel
       check_cluster_package gcc
    
       #初始化nginx
       init_nginx ${NGINX_USER} ${NGINX_USER}
    
       echo_fun 4 检查环境变量
       check_cluster_etc_profile  ${NGINX_INSTALL_PATH}/nginx   etc_nginx_profile
      
    
       #启动
       start_nginx
    }
    
    
    
    # ------------------------------------------------第八步----------------------------------------------------
     #定义修改es配置文件 
     function alter_es_config(){ 
       echo_fun 4 修改es配置文件内容
       sleep 1s
       cd ${ES_INSTALL_PATH}/elasticsearch/config 
    
       sed -i 's/#cluster.name: my-application/cluster.name: '"${cluster_name}"'/g' elasticsearch.yml
       sed -i 's/#node.name: node-1/node.name: '"${host_name[0]}"'/g' elasticsearch.yml
       sed -i 's/#path.data: \/path\/to\/data/path.data: '"${data_path}\/data"'/g' elasticsearch.yml
       sed -i 's/#path.logs: \/path\/to\/logs/path.logs: '"${logs_path}\/log"'/g' elasticsearch.yml
       sed -i 's/#network.host: 192.168.0.1/network.host: '"${host_ip[0]}"'/g' elasticsearch.yml
       sed -i '/#http.port: 9200/a\transport.tcp.port: 9300' elasticsearch.yml
       sed -i 's/#http.port: 9200/http.port: 9200/g' elasticsearch.yml
       sed -i 's/\["host1", "host2"\]//' elasticsearch.yml
       sed -i 's/#discovery.zen.ping.unicast.hosts:/discovery.zen.ping.unicast.hosts:/g' elasticsearch.yml
    
       for ((i=${#host_name[*]};i>0;i--))
       do
          sed -i '/discovery.zen.ping.unicast.hosts/a\               - '"${host_name[i-1]}"':9300' elasticsearch.yml
       done
       sed -i 's/#discovery.zen.minimum_master_nodes: 3/discovery.zen.minimum_master_nodes: 1/g' elasticsearch.yml
       sed -i '/#action.destructive_requires_name/a\bootstrap.system_call_filter: false' elasticsearch.yml
       sed -i '/#action.destructive_requires_name/a\http.cors.allow-origin: "*"' elasticsearch.yml
       sed -i '/#action.destructive_requires_name/a\http.cors.enabled: true' elasticsearch.yml
       sed -i '/#action.destructive_requires_name/a\node.data: true' elasticsearch.yml
       sed -i '/#action.destructive_requires_name/a\node.master: false' elasticsearch.yml
    
       } 
    
    #同步es安装包和软连接到其他的集群机器上并修改配置内容
    function rsync_tar(){
       echo_fun 4 同步es安装包和软连接到其他的集群机器上并修改配置内容
       sleep 1s
       cd ${ES_INSTALL_PATH}
    	 
       for ((i=1;i<${#host_name[*]};i++))
       do
       rsync -av elasticsearch  ${ES_VERSION} ${host_name[i]}:/opt  >/dev/null 2>&1
       ssh -Tq ${host_name[i]} <<remotessh
       cd ${ES_INSTALL_PATH}/elasticsearch/config
       sed -i 's/node.name: '"${host_name[0]}"'/node.name: '"${host_name[i]}"'/g' elasticsearch.yml
       sed -i 's/network.host: '"${host_ip[0]}"'/network.host: '"${host_ip[i]}"'/g' elasticsearch.yml
       exit
    remotessh
    done  
    echo_fun 2 修改成功
    } 
    
    
    function max_map_config(){
       echo_fun 5 检查vm.max_map_count的值
       for ip in ${host_ip[*]}
       do
         #获取是否存在vm.overcommit_memory的记录
         max_map=$(ssh $ip cat /etc/sysctl.conf | grep vm.max_map_count | wc -l )
         #获取是否存在vm.overcommit_memory的记录的value值为多少
         max_map_count=$(ssh $ip cat /etc/sysctl.conf | grep vm.max_map_count |awk '{print $3}' )
         if [ ${max_map} -eq 1 ];then
            if [ ${max_map_count} -ge 262144 ]; then
              echo_fun 2 $ip机器上存在vm.max_map_count,且值大于等于262144
              sysctl -p
            else
              #修改value值为262144
              echo_fun 3 $ip机器上存在vm.overcommit_memory,且值小于262144,需要修改
              #注意这里1262144第一个1不是数字概念
              ssh $ip "sed -i 's/$vm.max_map_count = $\S*/\1262144/' /etc/sysctl.conf"
              echo_fun 2 修改成功
              sysctl -p
            fi
         else
            echo_fun 4 $ip机器上不存在vm.max_map_count,需要添加
            ssh $ip "echo 'vm.max_map_count = 262144' >> /etc/sysctl.conf"
            echo_fun 2 添加成功
            sysctl -p
         fi
       done
    }
    
    #所以直接判断有没有这个用户的记录，如果没有就添加，有就手动去检查
    function limits_config(){
       for ip in ${host_ip[*]}
       do
         #根据用户来获取，一般是4行，如下
         # hadoop        hard  nproc    102400
         # hadoop        soft  nproc    102400
         # hadoop        hard  nofile   102400
         # hadoop        soft  nofile   102400
         nofile_nproc_num=$(ssh $ip cat /etc/security/limits.conf|grep -w $1 |wc -l)
         if [ ${nofile_nproc_num} -ge 4 ];then
           echo_fun 2 $ip机器已经设置了打开$1用户的最大进程数和文件数
         else
           echo_fun 3 $ip机器未设置打开$1用户最大进程数和文件数,进行设置
           ssh $ip "echo '$1        hard  nproc    102400' >>/etc/security/limits.conf;echo '$1        soft  nproc    102400' >>/etc/security/limits.conf;echo '$1        hard  nofile   102400' >>/etc/security/limits.conf;echo '$1        soft  nofile   102400' >>/etc/security/limits.conf"
           if [ $? -eq 0 ];then
             echo_fun 2 设置成功
           fi
         fi
       done
    }
    
    
    
    
    function start_es(){
      for ip in ${#host_ip[*]}
      do
        ssh -Tq root@${ip} <<remotessh
        su - ${ES_USER} <<EOF
        cd ${ES_INSTALL_PATH}/elasticsearch
        nohup ./bin/elasticsearch -d &
    EOF
        exit
    remotessh
       #判断进程是否存在
       es_pid_num=$(ssh ${ip} "ps -ef |grep $1|grep -v grep|wc -l")
       if [ ${es_pid_num} -ge 1 ];then
        echo_fun 2 ${ip}机器上的es has started.... 
       fi
       done
    }
    
    #获取安装机器ip
    function get_master_list(){
    	echo_fun 4 请输入master节点，多个ip之间用逗号隔开
    	read -p "master_list=" master_list
    	echo ''
    	str=${master_list//,/ }
    	master_ip=($str)
    }
    
    
    #安装es
    function step_fun_8(){
      #获取安装机器ip
      get_host_list
    
      #根据ip或者hostname值
      host_name=()
      for ((i=0;i<${#host_ip[*]};i++))
      do
        name=`cat /etc/hosts|grep "${host_ip[i]}"|awk '{print $2}'`
        host_name[$i]=$name
      done
    
      #es安装位置
      echo_fun 4 请输入es安装位置如[/opt]
      read -p "es_install_path=" ES_INSTALL_PATH
      echo ''
    
      echo_fun 4  检查es安装目录是否存在
    
      #循环检查/opt/elasticsearch目录是否存在
      check_cluster_catalog_exist ${ES_INSTALL_PATH}/elasticsearch elasticsearch
    
      #es启动用户
      echo_fun 5 请输入es的属组用户
      read -p "es_user=" ES_USER
      echo ''
    
      echo_fun  4 给es用户输入密码
      read -p "es_password=" ES_PASSWD
      echo ''
      
      check_cluster_exist_user ${ES_USER} ${ES_PASSWD}
     
     
      if [ $num -eq 0 ];then
         #解压es包
         echo_fun 4 解压es二进制包,并创建软连接
         extract_pkg ${SOFTWARE_PATH}  ${ES_VERSION}  ${ES_INSTALL_PATH} elasticsearch
         cd ${ES_INSTALL_PATH}
         chown -R ${ES_USER}:${ES_USER} elasticsearch*
         echo_fun 4 请输入集群名称
         read -p "es_name=" cluster_name
         echo ''
      
         echo_fun 4 请输入es存放数据目录,格式如'[\\\\/opt\\\\/data\\\\/elasticsearch]'
         read -p "data_path=" data_path
         echo ''
         for ip in ${host_ip[*]}
    	 do
    	   data_num=$(ssh $ip test -d ${data_path} &&  echo 1 || echo 0 )
    	   if [ ${data_num} -eq 0 ];then
    	    ssh $ip "mkdir -p ${data_path};chmod -R 777 ${data_path}"
           else
            chmod -R 777 ${data_path}		
           fi
    	 done
       
    
         echo_fun 4 请输入es存放日志目录,格式如'[\\\\/var\\\\/log\\\\/elasticsearch]'
         read -p "logs_path=" logs_path
         echo ''
         for ip in ${host_ip[*]}
    	 do
    	   log_num=$(ssh $ip test -d ${logs_path} &&  echo 1 || echo 0 )
    	   if [ ${log_num} -eq 0 ];then
    	     ssh $ip "mkdir -p ${logs_path};chmod -R 777 ${logs_path}" 
    	   else
             chmod -R 777 ${logs_path}
    	   fi
    	 done
    	
         #修改配置文件
         alter_es_config 
    
         #同步
         rsync_tar
        
    	 #获取master节点ip
         get_master_list
      
         for ((i=0;i<${#master_ip[*]};i++))
         do
           ssh -Tq ${master_ip[i]} <<remotessh
           cd ${ES_INSTALL_PATH}/elasticsearch/config
           sed -i 's/node.master: false/node.master: true/g' elasticsearch.yml
    	   sed -i 's/node.data: true/node.data: false/g' elasticsearch.yml
           exit
    remotessh
         done
       
         #删除
         remove_num=0
         remove_pkg  ${ES_INSTALL_PATH} ${ES_VERSION}
         if [ ${remove_num} -ne 1 ];then
       	   cd ${ES_INSTALL_PATH}
       	   rm -rf ${ES_INSTALL_PATH}/elasticsearch*
         fi
      fi 
     
       echo_fun 4 检查环境变量
       check_cluster_etc_profile ${ES_INSTALL_PATH}/elasticsearch  etc_es_profile
     
       max_map_config
       limits_config ${ES_USER}
       start_es Elasticsearch
    } 
    #----------------------------------------------第九步----------------------------------------------------
    
    #解压es-head的二进制包。
    function extract_es_head(){
      cd $1
      sleep 1s
      tar -xf ${ES_HEAD_VERSION}.tar.gz  -C ${ES_HEAD_INSTALL_PATH}
     
      cd ${ES_HEAD_INSTALL_PATH}/elasticsearch-head
      sed -i 's/localhost/'"${es_head_ip}"'/g' Gruntfile.js
      sed -i 's/localhost/'"${es_head_ip}"'/g' src/app/app.js
      sed -i 's/localhost/'"${es_head_ip}"'/g' _site/app.js
    }
    
    function start_es_head(){
     echo_fun 4 启动es-head插件
     ssh -Tq ${es_head_ip} <<remotessh
      cd  ${ES_HEAD_INSTALL_PATH}/elasticsearch-head
      nohup /opt/elasticsearch-head/node_modules/grunt/bin/grunt server >/dev/null 2>&1 &
      exit
    remotessh
    
       #判断进程是否存在
      es_head_pid_num=$(ssh ${es_head_ip} "ps -ef |grep -w grunt |grep -v  grep|wc -l")
      if [ ${es_head_pid_num} -ge 1 ];then
        echo_fun 2 es_head has started.... 
      else
        echo_fun 5 "es_head starting fail...."
      fi
    }
    
     
    
    function step_fun_9(){
    
       #获取安装机器ip
       echo_fun 4 请输入需要安装的机器ip
       read -p "es_head_ip=" es_head_ip
    
       echo_fun 4 请输入es-head安装位置如[/opt]
       read -p "es_head_install_path=" ES_HEAD_INSTALL_PATH
       echo ''
    
       #检查目录是否存在
       echo_fun 4 检查es-head安装目录是否存在 
    
       check_cluster_catalog_exist ${ES_HEAD_INSTALL_PATH}/${ES_HEAD_VERSION}  ${ES_HEAD_VERSION}
    
       if [ $num -eq 0 ];then
         #解压jdk包
         echo_fun 4 解压es-head二进制包,并修改配置文件
       
         extract_es_head ${SOFTWARE_PATH}
    
         #同步
         echo_fun 4 同步es-head目录到其安装机器上
      
         cd ${ES_HEAD_INSTALL_PATH}
         scp -r  ${ES_HEAD_VERSION}   ${es_head_ip}:${ES_HEAD_INSTALL_PATH}  >/dev/null 2>&1 
    
         #删除
         if [ ${local_ip} != ${es_head_ip} ];then
       	    cd ${ES_INSTALL_PATH}
       	    rm -rf  ${ES_HEAD_INSTALL_PATH}/${ES_HEAD_VERSION}
         fi
       fi 
    
        #启动
        start_es_head
    }
    
    
    # ------------------------------------------------程序开始----------------------------------------------------
    yn='y'
    echo_fun 1 部署脚本正在执行
    while [ "$yn" == "y" ];do 
      echo_list
      yn_install
      read -p '是否继续安装其他组件[y/n]:' yn
      echo ''
    done

执行的结果如下：

![70][]

![70 1][]

![70 2][]

安装之前会检查是否之前有过安装，和配置过环境变量。如果出现上述2种情况，则程序终止，需要手动检查。

正确安装结果如下：

![70 3][]

![70 4][]

![70 5][]

![70 6][]

![70 7][]

[70]: /images/20220519/53ba5e218948419396d6a7e3d5b1dc4b.png
[70 1]: /images/20220519/bcf74b831ee84f328d5c2c13315d7be2.png
[70 2]: /images/20220519/86ea41f86905473eb7074e57b648ea8b.png
[70 3]: /images/20220519/66a06e75ccb6426b890d15496ef823b6.png
[70 4]: /images/20220519/1af65d72d3854d788fa20e990ac734d5.png
[70 5]: /images/20220519/ca99e5c5351c49398cc0fc352dc0efa2.png
[70 6]: /images/20220519/6a61bf9d36d34ab0aa627529fadfb762.png
[70 7]: /images/20220519/a1af0f2da5ae4e1e8152691f6ec90668.png