1. 程式人生 > >shell指令碼一鍵部署jdk,python,mysql,postgresql,es等元件

shell指令碼一鍵部署jdk,python,mysql,postgresql,es等元件

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





執行的結果如下:

安裝之前會檢查是否之前有過安裝,和配置過環境變數。如果出現上述2種情況,則程式終止,需要手動檢查。

正確安裝結果如下: