Linux系统运维日志

单台机器部署多个 Tomcat, 每个Tomcat部署独立服务,Tomcat之间启停互不影响

不要问我为什么有这个需求, 复制粘贴就是干

0x00 单机多实例概述

大概的目录结构:

• CATALINA_HOME 为Tomcat应用程序运行程序及所需依赖
• CATALINA_BASE 即我们即将部署的程序

手动更改如下工作目录:

这是我自己个儿整的初始目录结构 download

war_apps                #手动创建用来存放下载好的war包文件
tomcat                  #CATALINA_HOME
├── bin
├── INIT_APPS_FILE      #CATALINA_BASE
│   ├── conf
│   ├── logs
│   ├── temp
│   ├── webapps
│   └── work
└── lib

然后呢正常的思路就是配置每个APP的server.xml端口:

- Server Port：该端口用于监听关闭tomcat的shutdown命令，默认为8005
- Connector Port：该端口用于监听HTTP的请求，默认为8080
- AJP Port：该端口用于监听AJP（ Apache JServ Protocol ）协议上的请求，通常用于整合Apache Server等其他HTTP服务器，默认为8009
- Redirect Port：重定向端口，出现在Connector配置中，如果该Connector仅支持非SSL的普通http请求，那么该端口会把 https 的请求转发到这个Redirect Port指定的端口，默认为8443；

应用太多你难道要一个个手动改? no no no! 上脚本

0x01 自动部署管理配置

需要把应用war包传到可下载位置,来用于应用分发,我这里是直接传到了阿里云的oss桶里

1.添加tomcat更新启停控制脚本

需要安装unzip yum -y install unzip

manage.sh需要放在这里,也可以自定义改代码

war_apps                #手动创建用来存放下载好的war包文件
tomcat                  #CATALINA_HOME
├── bin
├── manage.sh
├── INIT_APPS_FILE      #CATALINA_BASE
│   ├── conf
│   ├── logs
│   ├── temp
│   ├── webapps
│   └── work
└── lib

蓝色块需要根据实际情况自定义, 应用名称, 和war包下载地址不需要写,后面的python总控制台会自动分配

manage.sh

#!/bin/sh
# Author: Kionf
# description: 启动tomcat多实例.
# PATH=/opt/op/java/jdk1.8.0_172/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
# 应用名称
app=
# war包下载地址
war_url=
soft_dir="/opt/op"
download_war_file="${soft_dir}/war_apps/${app}.war"
export CATALINA_BASE="${soft_dir}/tomcat/$app"
export CATALINA_HOME="${soft_dir}/tomcat"
export JVM_OPTIONS="-Xms528m -Xmx812m -Xmn328m"
check(){
    PID=`ps aux|grep java|grep -w ${CATALINA_BASE}|awk '{print $2}'`
    if [ -n "$PID" ];then
        echo -e "33[94m $app is running PID:$PID"
        running=`netstat -ntlp|grep $PID|grep 127.0.0.1`
        if [ -n "$running" ];then
            echo -e "33[92m $app is provide services33[0m "
        else
            echo -e "33[93m $app is running but not provide services33[0m"
        fi
        return 0
    else
        echo -e "33[91m $app is dead33[0m "
        return 1
    fi
}
start() {
    check
    if [ $? -eq 1 ];then
        echo -e "33[94m Start $app 33[0m"
        $CATALINA_HOME/bin/startup.sh >/dev/null 2>&1
    fi
}
stop() {
    check
    if [ $? -eq 0 ];then
        echo -e "33[94m Stop $app33[0m"
        $CATALINA_HOME/bin/shutdown.sh >/dev/null 2>&1
        kill -9 $PID
    fi
}
update() {
    echo "下载文件"
    wget ${war_url} -O ${download_war_file} > /dev/null 2>&1
    if [ $? -eq 0 ];then
        cd ${CATALINA_BASE}/webapps/*/; unzip -q -o ${download_war_file} >/dev/null 2>&1
    fi
}
log() {
    tailf ${CATALINA_BASE}/logs/catalina.out
}
if [ $# != "0" ];then
    case "$1" in
        start)
            start
            ;;
        stop)
            stop
            ;;
        restart)
            stop
            start 
            ;;
        status)
            check
            ;;
        upgrade)
            stop
            update
            start
            ;;
        log)
            log
            ;;
        *)
            echo $"Usage: $0 {start|stop|restart|status|upgrade|log}"
            exit 1
            ;;
    esac
else
    start
    log
fi

2.添加总控制台脚本

我就放在了/usr/local/bin下, chmod +x /usr/local/bin/tomcat_manager 蓝色部分需要根据自己需求更改 (支持python2)

/usr/local/bin/tomcat_manager

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/5/23 15:18
# @Author  : Kionf
# @FileName: tomcat_manager.py
#
#   初始配置并管理单例tomcat多应用
#
import os
import subprocess
import sys
import shutil
# PATH = os.getcwd()
PATH = "/opt/op/tomcat"         #Tomcat目录
shell_script = os.path.join(PATH, "manage.sh")          #更新启停管理脚本
INIT_FILES = os.path.join(PATH, "INIT_APPS_FILE")
bucket = "https://oss.aliyuncs.com/tomcat_app/"         # webapp下载地址
config_data = {
    # 应用名: [ServerPort, ConnectPort, AJPPort, RedirectPort, ]
    'Application': ['8201', '8101', '8301', '8401', 'BaseApplication.war'],
    'BaseNotify_Service': ['8202', '8102', '8302', '8402', 'BaseNotify_Service.war'],
    'BaseUserCenter_Service': ['8203', '8103', '8303', '8403', 'BaseUserCenter_Service.war'],
}
def customize_print(msg, stat=0):
    if stat == 1:
        print("33[91m [ERROR]:  %s 33[0m" % msg)
    elif stat == 0:
        print("33[92m [INFO]:  %s 33[0m" % msg)
    elif stat == 2:
        print("33[93m [DEBUG]:  %s 33[0m" % msg)
class TomcatAppsManage:
    def __init__(self, webapp):
        self.name = webapp
        self.app_config = config_data[self.name]
        self.manage_shell_file = os.path.join(PATH, self.name, self.name)
        self.server_port, self.conn_port, self.ajp_port, self.redirect_port, self.app_war_name = self.app_config
        self.app_download_url = bucket + self.app_war_name
        self.config_file = os.path.join(PATH, self.name, 'conf/server.xml')
        self.webapp_dir = os.path.join(PATH, self.name)
    def create_app(self):
        """
        创建app
        :return:
        """
        if not os.path.exists(self.webapp_dir):
            customize_print("创建APP: %s" % self.name)
            shutil.copytree(INIT_FILES, self.webapp_dir)
            os.mkdir(os.path.join(self.webapp_dir, "webapps", self.name.lower()))
    def config_app_port(self):
        customize_print("正在修改APP：%s 配置" % self.name)
        change_port = {
            'ServerPort': "sed -i s'#Server port="[0-9]*"#Server port="" + self.server_port + ""#'g " + self.config_file,
            'ConnPort': "sed -i s'#Connector port="[0-9]*" protocol="HTTP/1.1"#Connector port="" + self.conn_port + "" protocol="HTTP/1.1"#'g " + self.config_file,
            'RedirectPort': "sed -i s'#redirectPort="[0-9]*"#redirectPort="" + self.redirect_port + ""#'g " + self.config_file,
            'AjpPort': "sed -i s'#Connector port="[0-9]*" protocol="AJP/1.3"#Connector port="" + self.ajp_port + "" protocol="AJP/1.3"#'g " + self.config_file,
        }
        for port in change_port.keys():
            # customize_print("修改 %s 端口" % port)
            os.system(change_port[port])
    def config_app_manage_shell(self):
        customize_print("%s 添加管理脚本" % self.name)
        copy_shell_script = 'cp -f ' + shell_script + ' ' + self.manage_shell_file
        os.system(copy_shell_script)
        config_script_app_name = "sed -i 's/app=/app="" + self.name + ""/' " + self.manage_shell_file
        os.system(config_script_app_name)
        config_script_war_url = "sed -i 's#war_url=#war_url="" + self.app_download_url + ""#' " + self.manage_shell_file
        os.system(config_script_war_url)
    def status_app(self):
        """
        :return: 0提供服务，1停止，2未提供服务
        """
        try:
            result = subprocess.check_output(['sh', self.manage_shell_file, 'status'])
        except subprocess.CalledProcessError as e:
            result = e.output
        if 'run' in result:
            if 'is provide services' in result:
                customize_print("应用 %s 成功启动并提供服务" % self.name)
                return 0
            elif 'but' in result:
                customize_print("应用 %s 进程存在但未提供服务" % self.name, 2)
                return 2
        else:
            customize_print("应用 %s 以停止" % self.name, 1)
            return 1
    def manage(self, operate):
        os.system('sh %s %s' % (self.manage_shell_file, operate))

    def init(self):
        self.create_app()
        self.config_app_port()
        self.config_app_manage_shell()
        self.manage("upgrade")
        self.manage("stop")
    def restart(self):
        self.manage("stop")
        self.manage("start")
    def start(self):
        self.manage("start")
    def stop(self):
        self.manage("stop")
    def log(self):
        self.manage("log")
    def upgrade(self):
        self.lock_config_file()
        self.manage("upgrade")
    def lock_config_file(self):
        cmd = 'find ' + self.webapp_dir + ' -name db*properties -o -name config_base_*|xargs chattr +i >/dev/null 2>&1'
        customize_print("锁配置文件", 2)
        os.system(cmd)
    def unlock_config_file(self):
        cmd = 'find ' + self.webapp_dir + ' -name db*properties -o -name config_base_*|xargs chattr -i >/dev/null 2>&1'
        customize_print("解锁配置文件", 2)
        os.system(cmd)
def dash_board(apps, operate):
    """
    主管理程序，调用
    :param operate: 应用操作
    :param apps: apps 为list
    """
    for app in apps:
        app_obj = TomcatAppsManage(app)
        main_dict = {
            "init": app_obj.init,
            "shell": app_obj.config_app_manage_shell,
            "status": app_obj.status_app,
            "start": app_obj.start,
            "stop": app_obj.stop,
            "restart": app_obj.restart,
            "upgrade": app_obj.upgrade,
            "log": app_obj.log,
            "lock": app_obj.lock_config_file,
            "unlock": app_obj.unlock_config_file,
        }
        try:
            main_dict[operate]()
        except KeyError as e:
            customize_print(help_msg)
help_msg = """
使用方法：
    1 log
    all status
    管理应用编号 操作
操作：
    lock        锁配置文件
    unlock      解锁配置文件
    init        配置tomcat监听端口
    shell       配置webapp控制脚本
    status，start，restart, log，upgrade，stop 应用操作
"""
def main():
    app_list = []
    for index, app_name in enumerate(config_data, 1):
        print "33[94m %s:  %s 33[0m" % (index, app_name)
        app_list.append(app_name)
    choice = raw_input("输入要管理的服务:  ")
    try:
        app_index = choice.split()[0]
        operate = choice.split()[1]
        if app_index.isdigit():
            app_index = int(app_index)
            if len(app_list) >= app_index > 0:
                app_name = app_list[app_index - 1]
                dash_board(app_name.split(), operate)
        elif app_index == "all":
            dash_board(app_list, operate)
    except ValueError and IndexError:
        customize_print("参数输入错误", 1)
        customize_print(help_msg)
if __name__ == '__main__':
    try:
        dash_board(sys.argv[1].split(), sys.argv[2])
    except IndexError:
        try:
            while True:
                main()
        except KeyboardInterrupt:
            customize_print("Bye!")

0x02 开始初始化部署

执行tomcat_manager

all init 自动初始化部署所有项目, 其他具体使用方法见帮助信息

1、下载 Tomcat 服务器

①、官网下载地址：http://tomcat.apache.org/

②、tomcat 8.0 64位百度云下载地址：http://pan.baidu.com/s/1slbKPsx 密码：ewui

③、tomcat 8.0 32位百度云下载地址：http://pan.baidu.com/s/1o8G28rS 密码：k11n

2、启动并部署 Tomcat 服务器

①、解压 tomcat 安装包到一个非中文目录下
②、配置环境变量。JAVA_HOME(指向 JDK 安装的根目录)
③、双击 apache-tomcat-6.0.16bin 目录下的 startup.bat，启动服务器(如果一闪而过，那就是没有配置 JAVA_HOME 的环境变量)
④、在浏览器中输入 http://localhost:8080

注意：Tomcat 启动不了的时候注意配置 JAVA_HOME:C:Program FilesJavajdk1.6.0_43这是安装 JDK的根目录

3、Tomcat 的目录结构

4、部署项目的第一种方法（项目直接放入 webapps 目录中）

1、将编写并编译好的web项目(注意要是编译好的，如果是 eclipse，可以将项目打成 war 包放入)，放入到 webapps 中

2、启动tomcat服务器（双击 apache-tomcat-6.0.16bin 目录下的 startup.bat，启动服务器）

3、在浏览器输入：http://localhost:8080/项目名/访问的文件名

5、部署项目的第二种方法（修改 conf/server.xml 文件 ）

①、打开tomcat下conf/server.xml，在 标签之间输入项目配置信息

<Context path="/WebProject" docBase="D:/WebProject" reloadable="true" />

path:浏览器访问时的路径名

docBase:web项目的WebRoot所在的路径，注意是WebRoot的路径，不是项目的路径。其实也就是编译后的项目

reloadble:设定项目有改动时，tomcat是否重新加载该项目

②、双击 startup.bat，启动 tomcat 服务器，然后在浏览器输入访问的项目名称路径

注意：如果你配置的 path=”/xx”,那么访问的时候就是这样：

6、部署项目的第三种方法（apache-tomcat-7.0.52confCatalinalocalhost ）

①、进入到 apache-tomcat-7.0.52confCatalinalocalhost 目录，新建一个 项目名.xml 文件

②、在 那个新建的 xml 文件中，增加下面配置语句（和上面的是一样的,但是不需要 path 配置，加上也没什么用）

<Context  docBase="D:/WebProject" reloadable="true" />

③、在浏览器输入路径：localhost:8080/xml文件名/访问的文件名

总结：

①、第一种方法比较普通，但是我们需要将编译好的项目重新 copy 到 webapps 目录下，多出了两步操作

②、第二种方法直接在 server.xml 文件中配置，但是从 tomcat5.0版本开始后，server.xml 文件作为 tomcat 启动的主要配置文件，一旦 tomcat 启动后，便不会再读取这个文件，因此无法再 tomcat 服务启动后发布 web 项目

③、第三种方法是最好的，每个项目分开配置，tomcat 将以confCatalinalocalhost 目录下的 xml 文件的文件名作为 web 应用的上下文路径，而不再理会 中配置的 path 路径，因此在配置的时候，可以不写 path。

通常我们使用第三种方法

摘要： Tomcat安装：wget http://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat-8/v8.5.31/bin/apache-tomcat-8.5.31.tar.gz 解压缩后直接在apache/bin目录下./startup.sh 启动小技巧：当出现Tomcat一直卡在启动页面时，可以是因为Java.security配置文件里写的是/dev/random，/dev/random和/dev/urandom是Linux系统中提供的随机伪设备，这两个设备的任务，是提供永不为空的随机字节数据流。

Tomcat安装：

wget http://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat-8/v8.5.31/bin/apache-tomcat-8.5.31.tar.gz

解压缩后直接在apache/bin目录下./startup.sh

启动小技巧：
当出现Tomcat一直卡在启动页面时，可以是因为Java.security配置文件里写的是/dev/random，/dev/random和/dev/urandom是Linux系统中提供的随机伪设备，这两个设备的任务，是提供永不为空的随机字节数据流。很多解密程序与安全应用程序（如SSH Keys,SSL Keys等）需要它们提供的随机数据流。当使用/dev/random因为需要生成随机数如果没有完成这个随机数的创建就会一直卡在启动页面。建议找到jdk1.x.x_xx/jre/lib/security/Java.security文件，在文件中找到securerandom.source这个设置项，将其改为：
securerandom.source=file:/dev/unrandom

在 apache/conf/server.xml目录下 tomcat默认参数设置：

• maxThreads：tomcat可用于请求处理的最大线程数，默认是200 —-连接数
• minSpareThreads：tomcat初始线程数，即最小空闲线程数 == minProcessors相同
• maxSpareThreads：tomcat最大空闲线程数，超过的会被关闭==maxThreads==maxProcessors
• acceptCount：当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理.默认100— 最大排队数

• minProcessors：最小连接线程数，用于提高系统处理性能，默认值为10

• maxProcessors：最大连接线程数，即：并发处理的最大请求数，默认值为75
• enableLookups：是否反查域名，取值为：true或false。为了提高处理能力，应设置为false
• connectionTimeout：网络连接超时，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。通常可设置为30000毫秒。

其中和最大连接数相关的参数为maxProcessors和acceptCount。如果要加大并发连接数，应同时加大这两个参数。

最大连接数 maxThreads
tomcat同时处理的线程数。

配置依据：

（1）、部署的程序偏计算型，主要利用cpu资源，应该将该参数设置小一点，减小同一时间抢占cpu资源的线程个数。
（2）、部署的程序对io、数据库占用时间较长，线程处于等待的时间较长，应该将该参数调大一点，增加处理个数。
最大排队数 acceptCount
当tomcat的线程数达到maxThreads后，新的请求就会排队等待，超过排队数的请求会被拒绝。
我一般设置和maxThreads相同。

“maxPostSize”该参数限制了post方式上传文件的大小，当maxPostSize<=0时，POST方式上传的文件大小不会被限制，maxPostSize参数只有当request的Content-Type为“application/x-www-form-urlencoded”时起作用。
“maxHttpHeaderSize”来自于客户端请求的Request和Response的HTTP,http请求头信息的最大程度，超过此长度的部分不予处理,一般8K。
“maxThreads”客户请求最大线程数,Tomcat使用线程来处理接收的每个请求。这个值表示Tomcat可创建的最大的线程数。
“minSpareThreads”最小空闲线程数,Tomcat初始化时创建的 socket 线程数.
“maxSpareThreads”最大连接线程数，即：并发处理的最大请求数，默认值为75,一旦创建的线程超过这个值，Tomcat就会关闭不再需要的socket线程。
“minProcessors”最小空闲连接线程数，用于提高系统处理性能，默认值为 10。
“acceptCount”允许的最大连接数，应大于等于 maxProcessors ，默认值为 100。
“enableLookups”若设为true, 则支持域名解析，可把 ip 地址解析为主机名,为了提高处理能力，应设置为false。
“compression”打开压缩功能。
“compressionMinSize “启用压缩的输出内容大小，这里面默认为2KB
“compressableMimeType”压缩类型。
“connectionTimeout”网络连接超时，单位：毫秒。设置为 0 表示永不超时，这样设置有隐患的。通常可设置为 30000 毫秒。
“URIEncoding”URL统一编码 。
“redirectPort”这里系统默认的，它指定转发端口，如果当前只支持non-SSL请求，在需要安全通信的场所，将把客户请求转发至SSL的redirectPort端口。
“disableUploadTimeout”上传时是否使用超时机制,如果不指定，该属性为“false”。

上述配置读者可通过实际业务需求进行调整，达到tomcat性能最优，关于更多tomcat详细部署读者可参考笔者的该篇文章，希望能有所帮助。