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

企业开发 2018-07-25 05:09:50 阅读次数: 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

host_name=(
wyl01
wyl02
wyl03
)

host_ip=(
10.10.252.151 
10.10.252.112 
10.10.252.127
)

#存放二进制包的路径
SOFTWARE_PATH='/opt/software'

#java部分信息
JDK_VERSION='jdk1.8.0_131'                                #jdk的版本
JDK_INSTALL_PATH='/opt'                                   #jdk的安装路径

#java部分信息
PYTHON_VERSION='python-2.7.8'                             #python的版本
PYTHON_INSTALL_PATH='/opt'                                #python的安装路径

#mysql部分信息 
MYSQL_VERSION='mysql-5.6.39-linux-glibc2.12-x86_64'       #mysql安装包名
MYSQL_INSTALL_PATH='/usr/local'                           #mysql安装的位置

#neo4j部分信息
NEO4J_VERSION='neo4j-community-3.1.4'                     #neo4j的版本，注意这里不.tar.gz
NEO4J_INSTALL_PATH='/opt'                                 #noe4j的安装路径

#postgresql部分信息
POSTGRESQL_VERSION='postgresql-9.6.3'                    #postgresql安装包名
POSTGRESQL_INSTALL_PATH='/opt/postgresql'                #postgresql安装的位置


#node.js部分信息，jdk要求1.8以上
NODE_VERSION='node-v8.9.0-linux-x64'                     #ndoe.js安装包名
NODE_INSTALL_PATH='/opt'                                 #node.js安装的位置

#nginx的部分信息
NGINX_VERSION='nginx-1.14.0'                             #nginx的版本
NGINX_INSTALL_PATH='/usr/local'                          #nnginx的安装路径



#es的部分信息
ES_HEAD_VERSION='elasticsearch-head'                    #es-head的版本
ES_HEAD_INSTALL_PATH='/opt'                             #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
}


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
)

function check_ok(){
  if [ $? -ne 0 ];then
    echo_fun 3 执行失败,请查看日志
    exit 1
  fi
}

function echo_list(){
  echo_fun 1 安装目录如下,请选择安装步骤1-9
  for (( i=0;i<${#install_list[@]};i++ ))
  do
    echo_fun 4 ${install_list[i]}
  done
}


function adduser(){  
  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}
}" 
}


function add_cluster_user(){

for ((i=0;i<${#host_name[*]};i++))
do
echo_fun 4  ${host_name[i]}机器添加用户,并设置密码
ssh -Tq ${host_name[i]} <<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
echo -e "\n"
done
}

function check_exist_user(){
num_user=`cat /etc/passwd|grep -w $1|wc -l`
if [ ${num_user} -eq 1 ];then
   echo_fun 2 该机器已经创建了$1用户,无需再创建,继续下一步
   num_user=`echo 1`
else
   echo_fun 4 创建$1用户
   num_user=`echo 0`
fi
}

function check_cluster_exist_user(){
for ip in ${host_name[*]}
do
  echo_fun 5 检查$ip机器上的$1用户是否存在
  cluster_num_user=$(ssh $ip cat /etc/passwd|grep -w $1|wc -l )
  if [ ${cluster_num_user} -eq 1 ];then
    echo_fun 2 $ip机器已经创建了$1用户,无需再创建,继续下一步
    cluster_user_num=`echo 1`
  else
    echo_fun 4 $ip机器上的$1用户不存在，需要创建
    cluster_user_num=`echo 0`
  fi
done
}




function check_catalog_exist(){
 test -d $1 && echo_fun 5 $1的安装目录已经存在,请检查 && exit
}

function check_cluster_catalog_exist(){
for ip in ${host_name[*]}
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_package(){
package_num=`rpm -qa|grep $1|wc -l `

if [ $package_num -lt 1 ];then
  echo_fun 5 缺少$1的依赖包,安装依赖
  yum install -y $1
  check_ok
fi
}

function check_cluster_package(){
for ip in ${host_name[*]}
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 缺少$1的依赖包,安装依赖
    ssh $ip "yum install -y $1"
    check_ok
 fi
done

}


#检查环境变量---单台
function check_etc_profile(){
echo_fun 4 配置环境变量
#检查环境变量中是否已经配置了
path_num=`cat /etc/profile |grep -w $1 |wc -l `
if [ ${path_num} -ge 1 ];then
   echo_fun 5 该机器环境变量中已经配置,请检查准确性
   #回滚，删除之前的软连接和安装包
   rm -rf $1
   rm -rf $2
   exit
fi
}

#检查环境变量--多台
function check_cluster_etc_profile(){
for ip in ${host_name[*]}
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机器上环境变量中已经配置,请检查准确性
   exit
  fi 
done
}




# ------------------------------------------------第一步----------------------------------------------------


#解压jdk的二进制包，并设置软连接，和改变其属组属性。
function extract_jdk(){
cd $SOFTWARE_PATH
sleep 1s
echo_fun 4 解压jdk二进制包,并创建软连接
tar -xf ${JDK_VERSION}.tar.gz  -C  ${JDK_INSTALL_PATH}
ln -s ${JDK_INSTALL_PATH}/${JDK_VERSION}   ${JDK_INSTALL_PATH}/java
}

#同步jdk安装包和软连接到其他的集群机器上
function rsync_jdk(){
echo_fun 4 同步jdk目录和软连接到其他的集群机器上
sleep 1s
cd ${JDK_INSTALL_PATH}
for ((i=1;i<${#host_name[*]};i++))
do
rsync -av java  ${JDK_VERSION} ${host_name[i]}:/opt  >/dev/null 2>&1
done
  check_ok
  echo_fun 2 同步成功
}



#安装jdk
function step_fun_1(){

echo_fun 4  检查java安装目录是否存在

#循环检查/opt/java目录是否存在
check_cluster_catalog_exist ${JDK_INSTALL_PATH}/java java

if [ $num -eq 0 ];then
  #解压jdk包
   extract_jdk
  #同步
   rsync_jdk
fi

echo_fun 4 检查环境变量
check_cluster_etc_profile ${JDK_INSTALL_PATH}/java ${JDK_INSTALL_PATH}/${JDK_VERSION}

if [ ${cluster_path_num} -lt 1 ];then
   echo_fun 4 配置环境变量
   for ((i=0;i<${#host_name[*]};i++))
   do
      echo_fun 4 配置${host_name[i]}机器上的环境变量
      ssh -Tq root@${host_name[i]} <<remotessh
      echo -e '\nexport JAVA_HOME=${JDK_INSTALL_PATH}/java\nexport PATH=\${JAVA_HOME}/bin:\$PATH'>> /etc/profile
      source /etc/profile
      exit
remotessh
   done
fi 
}


#--------------------------------------------------第二步----------------------------------------------------


#解压python的二进制包，并设置软连接，和改变其属组属性。
function extract_python(){
cd $SOFTWARE_PATH
sleep 1s

echo_fun 4 解压python二进制包,并创建软连接
tar -xf ${PYTHON_VERSION}.tar.gz  -C  ${PYTHON_INSTALL_PATH}
ln -s ${PYTHON_INSTALL_PATH}/${PYTHON_VERSION}   ${PYTHON_INSTALL_PATH}/python
}

#同步python安装包和软连接到其他的集群机器上
function rsync_python(){
echo_fun 4 同步jdk目录和软连接到其他的集群机器上
sleep 1s
cd ${JDK_INSTALL_PATH}
for ((i=1;i<${#host_name[*]};i++))
do
rsync -av python  ${PYTHON_VERSION} ${host_name[i]}:/opt   >/dev/null 2>&1
done
  check_ok
  echo_fun 2 同步成功
}

function step_fun_2(){
echo_fun 4  检查python安装目录是否存在
#循环检查/opt/python目录是否存在
check_cluster_catalog_exist ${PYTHON_INSTALL_PATH}/python  python

if [ $num -eq 0 ];then
  #解压python包
   extract_python
  #同步python
   rsync_python
fi

echo_fun 4 检查环境变量
check_cluster_etc_profile ${PYTHON_INSTALL_PATH}/python

if [ ${cluster_path_num} -lt 1 ];then
   echo_fun 4 配置环境变量
   for ((i=0;i<${#host_name[*]};i++))
   do
      echo_fun 4 配置${host_name[i]}机器上的环境变量
      ssh -Tq root@${host_name[i]} <<remotessh
      echo -e '\nexport PYTHON_HOME=${PYTHON_INSTALL_PATH}/python\nexport PATH=\${PYTHON_HOME}/bin:\$PATH'>> /etc/profile
      source /etc/profile
      exit
remotessh
   done
fi 
}

#----------------------------------------------------第三步------------------------------------------------------


#初始化mysql
function extract_init_mysql(){ 
cd $SOFTWARE_PATH
echo_fun 4 解压mysql,并创建软连接
tar -xf ${MYSQL_VERSION}.tar.gz  -C  ${MYSQL_INSTALL_PATH}
ln -s ${MYSQL_INSTALL_PATH}/${MYSQL_VERSION}   ${MYSQL_INSTALL_PATH}/mysql
check_ok
chown -R mysql:mysql ${MYSQL_INSTALL_PATH}/mysql*

echo_fun 4 初始化mysql
cd  ${MYSQL_INSTALL_PATH}/mysql
cp support-files/my-default.cnf  /etc/my.cnf
cp support-files/mysql.server  /etc/init.d/mysql.server
scripts/mysql_install_db --user=mysql
check_ok
}


#启动mysql
function start_mysql(){
if [ $RELEASE = '6' ];then
  service mysql.server start
  check_ok
elif [ $RELEASE = '7'];then 
  systemctl start mysql.server
fi

mysql_pid_num=`ps -ef |grep mysqld|grep -v grep|wc -l`
if [ $mysql_pid_num -ge 2 ];then
  echo_fun 2 安装成功,并已经启动mysql服务
else
  echo_fun 3 安装失败
fi

}

#初始化mysql的root用户密码
function init_mysql_passwd(){
echo_fun 4 初始化mysql的root用户密码
mysql  -uroot << EOF 
set password = password("baifendian");
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'baifendian';
GRANT ALL PRIVILEGES ON *.* TO 'root'@localhost IDENTIFIED BY 'baifendian';
flush privileges;
EOF
}


#安装mysqll
function step_fun_3(){

#获取操作系统的版本号
RELEASE=`lsb_release -a |grep  Release |awk '{print $2}'|awk -F '.' '{print $1}'`

#检查/usr/local目录下有没有mysql目录
echo_fun 4  检查mysql安装目录是否存在
check_catalog_exist ${MYSQL_INSTALL_PATH}/mysql 

echo_fun 4 检查是否存在mysql用户
check_exist_user  mysql

if [ $num_user -eq 0 ]; then
  echo_fun  4 给mysql用户输入密码
  read -p "password=" mysql_password
  adduser mysql ${mysql_password}
fi


extract_init_mysql

echo_fun 4 检查环境变量
check_etc_profile ${MYSQL_INSTALL_PATH}/mysql  ${MYSQL_INSTALL_PATH}/${MYSQL_VERSION}

#配置环境变量
if [ ${path_num} -lt 1 ];then
   echo -e '\nexport MYSQL_HOME='${MYSQL_INSTALL_PATH}'/mysql\nexport PATH=${MYSQL_HOME}/bin:$PATH'>> /etc/profile
   source /etc/profile
fi

check_ok
start_mysql

#设置开机自启动
echo_fun 4 设置开机自启动
chkconfig mysql.server on
check_ok
init_mysql_passwd
}

#------------------------------------------------第四步-----------------------------------------------------------

#解压neo4j的二进制包，并设置软连接，和改变其属组属性。
function extract_neo4j(){
cd $SOFTWARE_PATH
echo_fun 4 解压neo4j二进制包,并创建软连接
tar -xf ${NEO4J_VERSION}-unix.tar.gz  -C  ${NEO4J_INSTALL_PATH}
check_ok
ln -s ${NEO4J_INSTALL_PATH}/${NEO4J_VERSION}   ${NEO4J_INSTALL_PATH}/neo4j

cd ${NEO4J_INSTALL_PATH}
chown -R $1:$1 ${NEO4J_INSTALL_PATH}/neo4j*
sleep 1s
}

function alter_neo4j_config(){

echo_fun 4 修改neo4j配置文件内容
sleep 1s
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=:7687/dbms.connector.bolt.listen_address='"${host_ip[0]}"':7687/g' neo4j.conf
sed -i 's/#dbms.connector.http.listen_address=:7474/dbms.connector.http.listen_address='"${host_ip[0]}"':7474/g' neo4j.conf
sed -i 's/#dbms.connector.https.listen_address=:7473/dbms.connector.https.listen_address='"${host_ip[0]}"':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 's/#dbms.shell.host=127.0.0.1/dbms.shell.host='"${host_ip[0]}"'/g' neo4j.conf
sed -i '/#dbms.shell.port=1337/s/^#//' neo4j.conf
}

function start_neo4j(){
echo_fun 4 启动neo4j进程
su - ${NEO4J_USER} <<EOF
cd /opt/neo4j
nohup ./bin/neo4j start >/home/${NEO4J_USER}/neo4j.log 2>&1
EOF
}


function step_fun_4(){

echo_fun 4 检查neo4j安装目录是否存在
check_catalog_exist  ${NEO4J_INSTALL_PATH}/${NEO4J_VERSION}


echo_fun 5 请输入neo4j的属组用户
read -p "neo4j_user=" neo4j_user

check_exist_user ${neo4j_user}

if [ $num_user -eq 0 ]; then
  echo_fun  4 给neo4j用户输入密码
  read -p "neo4j_password=" neo4j_passwd
  adduser ${neo4j_user} ${neo4j_passwd}
fi

#解压，设置软连接
extract_neo4j ${neo4j_user}
#修改配置文件
alter_neo4j_config

#检查环境变量
echo_fun 4 检查环境变量
check_etc_profile ${NEO4J_INSTALL_PATH}/neo4j ${NEO4J_INSTALL_PATH}/${NEO4J_VERSION}

#配置环境变量
if [ ${path_num} -lt 1 ];then
   echo -e '\nexport NEO4J_HOME='${NEO4J_INSTALL_PATH}'/neo4j\nexport PATH=${NEO4J_HOME}/bin:$PATH'>> /etc/profile
   source /etc/profile
fi


#启动neo4j
start_neo4j

neo4j_pid_num=`ps -ef |grep neo4j|grep -v grep|wc -l`

if [ ${neo4j_pid_num} -eq 1 ];then
 echo_fun 2 neo4j has started....
 echo_fun 2 在浏览器输入${host_ip[0]}:7474
else
  echo_fun 3 启动失败,请查看错误日志信息/home/${NEO4J_USER}/neo4j.log
fi

}

#-------------------------------------------------------第五步--------------------------------------------------

#postgresql源码解压编译
function config_psql(){
echo_fun 4 编译安装,等待时间较长. . .
cd $SOFTWARE_PATH
tar -xf ${POSTGRESQL_VERSION}.tar.gz
cd ${POSTGRESQL_VERSION}

#检查并解决依赖
check_package readline-devel
check_package zlib-devel

#编译
./configure --prefix=${POSTGRESQL_INSTALL_PATH}
sleep 10s
make && make install
check_ok
}



function step_fun_5(){

echo_fun 4 检查postgresql目录是否存在
check_catalog_exist ${POSTGRESQL_INSTALL_PATH}
#解压，编译
config_psql

#创建用户,用来启动postgresql
echo_fun 5 建议创建一个[postgres]用户，用来启动postgresql
read -p "psql_user=" psql_user

check_exist_user $psql_user

if [ ${num_user} -eq 0 ]; then
  echo_fun 5 给postgresql用户输入密码
  read -p "psql_passwd=" psql_passwd
  adduser $psql_user $psql_passwd 
fi

cd ${POSTGRESQL_INSTALL_PATH}/../
chown -R ${psql_user}:${psql_user}  ${POSTGRESQL_INSTALL_PATH}


#配置环境变量和指定PGDATA位置
echo_fun 4 配置环境变量和指定PGDATA位置

check_etc_profile ${POSTGRESQL_INSTALL_PATH}

if [ ${path_num} -lt 1 ];then
 echo -e '\nexport POSTGRESQL_HOME='${POSTGRESQL_INSTALL_PATH}'\nexport PATH=${POSTGRESQL_HOME}/bin:$PATH\nexport PGDATA='${POSTGRESQL_INSTALL_PATH}'/data\n'>> /etc/profile
 source /etc/profile
fi

#初始化postgresql数据库
echo_fun 4 初始化postgresql数据库
su - ${psql_user} <<EOF
initdb
sleep 10s
EOF

#修改postgresql的配置文件
echo_fun 4 修改postgresql的配置文件
cd ${POSTGRESQL_INSTALL_PATH}/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
check_ok

#启动postgresql
echo_fun 4 启动postgresql
su - ${psql_user} <<EOF
pg_ctl -D ${POSTGRESQL_INSTALL_PATH}/data -l logfile start
EOF

#检查postgresql启动进程
psql_pid_num=`ps -ef |grep ${POSTGRESQL_INSTALL_PATH}/data|grep -v grep|wc -l`
if [ ${psql_pid_num} -eq 1 ];then
  echo_fun 2 安装成功,并已经启动postgresql服务
else
  echo_fun 3 安装失败
fi

}


#---------------------------------------------------------第六步------------------------------------------------

#安装node.js
function step_fun_6(){

cd $SOFTWARE_PATH
#解压,设置软连接
check_catalog_exist ${NODE_INSTALL_PATH}/node

tar -xf ${NODE_VERSION}.tar.gz  -C  ${NODE_INSTALL_PATH}
check_ok
ln -s ${NODE_INSTALL_PATH}/${NODE_VERSION}   ${NODE_INSTALL_PATH}/node

#配置环境变量
check_etc_profile ${NODE_INSTALL_PATH}/node  ${NODE_INSTALL_PATH}/${NODE_VERSION}

if [ ${path_num} -lt 1 ];then
 echo -e '\nexport NODE_HOME='${NODE_INSTALL_PATH}'/node\nexport PATH=${NODE_HOME}/bin:$PATH'>> /etc/profile
 source /etc/profile
fi

echo_fun 4 检查node版本

echo_fun 5 'node.js的版本号为:'`node -v`
if [ $? -eq 0 ];then
  echo_fun 2 node.js安装成功
fi
}



#----------------------------------------------------------第七步-----------------------------------------------

#解压ngxin的二进制包。
function extract_nginx(){
  cd ${SOFTWARE_PATH}
  echo_fun 4 解压nginx二进制包,并创建软连接
  tar -xf ${NGINX_VERSION}.tar.gz 
  cd ${NGINX_VERSION}
  ./configure --prefix=./configure --prefix=${NGINX_INSTALL_PATH}/nginx --user=nginx --group=nginx --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
  check_ok
  make && make install
  check_ok
}


function start_nginx(){
echo_fun 4 启动nginx
cd ${NGINX_INSTALL_PATH}/nginx
nohup nginx >/home/${NGINX_USER}/nginx.log 2>&1
sleep 15s
nginx_pid_num=`ps -ef|grep  nginx|grep -v grep|wc -l`
if [ ${nginx_pid_num} -ge 1 ];then
 echo_fun 2 nginx has started....
fi
}



#nginx的部署
function step_fun_7(){
#检查nginx安装目录
check_catalog_exist ${NGINX_INSTALL_PATH}/nginx
#解压nginx
extract_nginx

echo_fun 5 请创建nginx的work进程启动用户[nginx]
read -p "nginx_user=" nginx_user

check_exist_user ${nginx_user}

if [ ${num_user} -eq 0 ]; then
  echo_fun 5 给${nginx_user}用户输入密码
  read -p "nginx_passwd=" nginx_passwd
  adduser $nginx_user $nginx_passwd 
fi

check_package openssl-devel
check_package pcre-devel
check_package zlib-devel
check_package gcc

check_etc_profile ${NGINX_INSTALL_PATH}/nginx
if [ ${path_num} -lt 1 ];then
   echo -e '\nexport NGINX_HOME='${NGINX_INSTALL_PATH}'/nginx\nexport PATH=${NGINX_HOME}/sbin:$PATH'>> /etc/profile
   source /etc/profile
fi

#启动nginx
start_nginx
}



#---------------------------------------------------------第八步----------------------------------------------------

ES_VERSION='elasticsearch-5.2.2'            #es的版本，注意这里不.tar.gz
ES_INSTALL_PATH='/opt'                      #es的安装路径

data_path='\/opt\/elasticsearch\/data'      #es的数据存放路径
logs_path='\/opt\/elasticsearch\/log'       #es日志存放路径

#解压es的二进制包，并设置软连接，和改变其属组属性。
function extract_es(){
cd $SOFTWARE_PATH
sleep 1s

echo_fun 4 解压es二进制包,并创建软连接
tar -xf ${ES_VERSION}.tar.gz  -C  ${ES_INSTALL_PATH}
ln -s ${ES_INSTALL_PATH}/${ES_VERSION}   ${ES_INSTALL_PATH}/elasticsearch

cd ${ES_INSTALL_PATH}
chown -R $1:$1 ${ES_INSTALL_PATH}/elasticsearch*
sleep 1s
}



#定义修改es配置文件

function alter_es_config(){

echo_fun 4 修改es配置文件内容
sleep 1s
cd ${ES_INSTALL_PATH}/elasticsearch/config

data_path='\/opt\/elasticsearch\/data'
logs_path='\/opt\/elasticsearch\/log'
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}"'/g' elasticsearch.yml
sed -i 's/#path.logs: \/path\/to\/logs/path.logs: '"${logs_path}"'/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: true' 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
check_ok
 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
sed -i 's/node.master: true/node.master: false/g' elasticsearch.yml
exit
remotessh
done
  echo_fun 2 修改成功
}


#配置环境变量
function etc_es_profile(){
for ((i=0;i<${#host_name[*]};i++))
do
echo_fun 4 配置${host_name[i]}机器上的环境变量

done
}


function max_map_config(){
echo_fun 5 检查vm.max_map_count的值
for ip in ${host_name[*]}
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_name[*]}
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机器已经设置了打开最大进程数和文件数
  else
    echo_fun 3 $ip机器未设置,进行设置
    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 ((i=0;i<${#host_name[*]};i++))
do
ssh -Tq root@${host_name[i]} <<remotessh
su - hadoop <<EOF
cd ${ES_INSTALL_PATH}/elasticsearch
nohup ./bin/elasticsearch -d &
if [ $? -eq 0 ];then
  echo -e "\033[32;40;1m ${host_name[i]}机器上的 es has started....\033[0m\r\n" 
fi
EOF
exit
remotessh
done
}



function step_fun_8(){

#检查目录是否存在
echo_fun 4 检查es安装目录是否存在
check_cluster_catalog_exist $ES_INSTALL_PATH/elasticsearch  elasticsearch

 
 echo_fun 5 请输入ES的属组及启动用户
 read -p "es_user=" es_user

 check_cluster_exist_user ${es_user}


 if [ $cluster_user_num -eq 0 ]; then
   echo_fun 5 给${nginx_user}用户输入密码
   read -p "es_passwd=" es_passwd
   add_cluster_user ${es_user} ${es_passwd}
 fi

 extract_es ${es_user}

 echo_fun 5 '请输入es集群名字'
 read -p "cluster_name="  cluster_name
 alter_es_config ${cluster_name}

 rsync_tar

#配置环境变量
check_cluster_etc_profile ${ES_INSTALL_PATH}/elasticsearch  ${ES_INSTALL_PATH}/${ES_VERSION}

if [ ${cluster_path_num} -lt 1 ];then
  for (( i = 0; i < ${#host_name[*]}; i++ )); do
  ssh -Tq root@${host_name[i]} <<remotessh
      echo -e "\033[33;40;1m  配置${host_name[i]}机器上环境变量 \033[0m\r\n"
      echo -e '\nexport ES_HOME=${ES_INSTALL_PATH}/elasticsearch\nexport PATH=\${ES_HOME}/bin:\$PATH'>> /etc/profile
      source /etc/profile
      exit
remotessh
   done
fi 


#修改系vm_max_map的值，以及打开最大文件数和进程数
max_map_config
limits_config ${es_user}

start_es 
}


#--------------------------------------------------第九步----------------------------------------------------


#解压es-head的二进制包。
function extract_es_head(){
  cd $SOFTWARE_PATH
  sleep 1s
  echo_fun 4 解压es-head二进制包,并修改配置文件
  tar -xf ${ES_HEAD_VERSION}.tar.gz  -C ${ES_HEAD_INSTALL_PATH}
  check_ok
  cd ${ES_HEAD_INSTALL_PATH}/elasticsearch-head
  sed -i 's/localhost/'"${host_ip[0]}"'/g' Gruntfile.js
  sed -i 's/localhost/'"${host_ip[0]}"'/g' src/app/app.js
  sed -i 's/localhost/'"${host_ip[0]}"'/g' _site/app.js
}

function start_es_head(){
 echo_fun 4 启动es-head插件
 nohup /opt/elasticsearch-head/node_modules/grunt/bin/grunt server >/dev/null 2>&1
 num=`ps -ef |grep -w grunt |grep -v  grep|wc -l`
 if [[ $num -eq 1 ]];then 
   echo_fun 2 es-head has started....
 fi
}


function step_fun_9(){
#检查目录是否存在
echo_fun 4 检查es-head安装目录是否存在

check_catalog_exist ${ES_HEAD_INSTALL_PATH}/${ES_HEAD_VERSION}
#解压并修改配置文件
extract_es_head
#启动
start_es_head
}


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

}



yn='y'
while [ "$yn" == "y" ];do 
  echo_list
  yn_install
  read -p '是否继续安装[y/n]:' yn
  done

执行的结果如下：

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

正确安装结果如下：

猜你喜欢

转载自blog.csdn.net/wyl9527/article/details/81186281
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022